}

        void assertIsTool() {
            assertIs(ProductType.TOOL)
            this.buildConfigurationList.buildConfigurations.each { ProjectFile.PBXTarget.assertNotUnitTestBuildSettings(it.buildSettings) }
        }

        void assertIsDynamicLibrary() {
            assertIs(ProductType.DYNAMIC_LIBRARY)

        expect:
        cachePolicy.eachModule(new Action<ModuleResolutionControl>() {
            void execute(ModuleResolutionControl t) {
                assertId(t.request, 'g', 'n', 'v')
                assertId(t.cachedResult.id, 'group', 'name', 'version')
                assert !t.changing
                t.refresh()
            }
        })

            }
        });
    }

    /**
     * Executes the requested build, asserting that the build succeeds. Resets the configuration of this executer.
     *
     * @return The result.
     */
    ExecutionResult run();

    /**
     * Executes the requested build, asserting that the build fails. Resets the configuration of this executer.
     *
     * @return The result.
     */

    sample = {'input_tensor': input_tensor_value}

    feed_dict = repr_dataset.create_feed_dict_from_input_data(
        sample, signature_def
    )

    self.assertLen(feed_dict, 1)
    self.assertIn('input:0', feed_dict)
    self.assertAllEqual(feed_dict['input:0'], input_tensor_value)

  @test_util.deprecated_graph_mode_only
  def test_create_feed_dict_from_input_data_core_tensors(self):

    data.write("8900".decodeHex()) // Empty ping
    clientReader.processNextFrame()
    callback.assertPing(EMPTY)
  }

  @Test fun pingCallsCallback() {
    data.write("890548656c6c6f".decodeHex()) // Ping with "Hello"
    clientReader.processNextFrame()
    callback.assertPing("Hello".encodeUtf8())
  }

  @Test fun emptyCloseCallsCallback() {
    data.write("8800".decodeHex()) // Empty close

	ClusterMatched     string
	// StrictMatch controls whether we will strictly match the result. If unset, empty fields will
	// be ignored, allowing testing only fields we care about This allows asserting that the result
	// is *exactly* equal, allowing asserting a field is empty
	StrictMatch bool
	// If set, this will mark a test as skipped. Note the result is still checked first - we skip only

                }
            }
        }
    }

    void noBuildTriggered(int waitSeconds = 3) {
        // TODO - change this general strategy to positively detect changes we are ignoring instead of asserting that a build doesn't happen in some time frame
        try {
            ConcurrentTestUtil.poll(waitSeconds, 0.5) {
                // force the poll to continue while there is no output

                                   int path_idx) {
  std::vector<IslandOp> path;
  bool found_path = FindPathBfs(source_op, target_op, path);
  if (!found_path) {
    // This shouldn't happen, returning an error instead of asserting so it
    // doesn't go unnoticed if it ever happens.
    target_op.emitError("no path to target op found, cannot emit warnings");
    return;
  }

  // Emit warnings for path.
  int node_idx = 0;

     */
    void expectHead(String path, File srcFile) {
        expect(path, false, ['HEAD'], fileHandler(path, srcFile))
    }

    /**
     * Expects one HEAD request for the given URL, asserting that the request is revalidated.
     */
    void expectHeadRevalidate(String path, File srcFile) {
        expect(path, false, ['HEAD'], revalidateFileHandler(path, srcFile))
    }

    /**

import java.util.Iterator;
import java.util.List;
import java.util.Map.Entry;
import java.util.Set;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * A series of tests that support asserting that collections cannot be modified, either through
 * direct or indirect means.
 *
 * @author Robert Konigsberg
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
public class UnmodifiableCollectionTests {