ArrayRef<int64_t> shape_y1 =
      shape_lhs.drop_front(shape_b.size()).drop_back(shape_c.size());

  // Check %before shape, and extract Y2 from it.
  ArrayRef<int64_t> shape_before = reshape_before.getType().getShape();
  if (shape_before.take_front(shape_b.size()) != shape_b ||
      shape_before.take_back(shape_c.size()) != shape_c) {
    return failure();
  }
  ArrayRef<int64_t> shape_y2 =

				Valu("a", OpConstBool, types.Types[types.TBOOL], 1, nil),
				If("p", blockn(i+1), blockn(size))))
		}
	}

	blocs = append(blocs,
		Bloc(blockn(size), Goto("exit")),
		Bloc("exit", Exit("mem")),
	)

	return blocs
}

// genMaxPred maximizes the size of the 'exit' predecessor list.
func genMaxPred(size int) []bloc {
	var blocs []bloc
	blocs = append(blocs,
		Bloc("entry",

        def extractedAnn = api.extractAndLoadApiClassFrom(annClazz)
        def extractedAnnotations = extractedClass.annotations

        then:
        annotations.size() == 1
        annotations[0].annotationType().name == 'Ann'
        extractedAnnotations.size() == 1
        extractedAnnotations[0].annotationType() == extractedAnn
    }

    void "annotations on method are retained"() {
        given:
        def api = toApi([

        }

        protected IndexOutOfBoundsException outOfBounds(int index) {
            return new IndexOutOfBoundsException("Index: " + index + ", Size: " + size());
        }

        private class SubList extends AbstractImmutableList<E> {
            private final int fromIndex;
            private final int toIndex;

            private SubList(int fromIndex, int toIndex) {
                this.fromIndex = fromIndex;

		if err != nil {
			err = errObjectTampered // assign correct error type
		}
		return int64(size), err
	}

	var size int64
	for _, part := range o.Parts {
		partSize, err := sio.DecryptedSize(uint64(part.Size))
		if err != nil {
			return 0, errObjectTampered
		}
		size += int64(partSize)
	}
	return size, nil
}

    @Test
    fun `promotion project has expected build types for master branch`() {
        val model = setupModelFor("master")

        assertEquals("Promotion", model.name)
        assertEquals(10, model.buildTypes.size)
        assertEquals(

            info.@revision == "my-version"
            ******@****.***y()
            ******@****.***y()
            configurations.size() == 1
            configurations.conf.isEmpty()
            publications.size() == 1
            publications.artifacts.isEmpty()
            dependencies.size() == 1
            dependencies.dependency.isEmpty()
        }
    }

    def "encodes coordinates for XML and unicode"() {

			N:     l.Totals[i].N + o.Totals[i].N,
			Size:  l.Totals[i].Size + o.Totals[i].Size,
		}
	}
	return merged
}

// Add  a new duration data
func (l *ReplicationLastHour) addsize(sz int64) {
	min := time.Now().Unix() / 60
	l.forwardTo(min)
	winIdx := min % 60
	l.Totals[winIdx].merge(AccElem{Total: min, Size: sz, N: 1})
	l.LastMin = min
}

        with(realize) {
            progress.size() == 1
            with(progress[0]) {
                detailsClassName == LogEvent.name
                details.message.startsWith("create")
            }

            children.size() == 2
            with(children[0]) {
                progress.size() == 1
                progress[0].detailsClassName == LogEvent.name

        // Extract and assert the wrapper failure
        collector.failures.size() == 1
        collector.failures[0] instanceof TestAssertionFailure
        def failure = collector.failures[0] as TestAssertionFailure
        failure.message == "This exception wraps an assertion error"

        // Extract and assert the wrapped failure
        failure.causes.size() == 1
        failure.causes[0] instanceof TestAssertionFailure