}
        Set<Configuration> result = WrapUtil.toLinkedSet(this);
        collectSuperConfigs(this, result);
        return result;
    }

    private void collectSuperConfigs(Configuration configuration, Set<Configuration> result) {
        for (Configuration superConfig : configuration.getExtendsFrom()) {
            // The result is an ordered set - so seeing the same value a second time pushes further down

		return nil, false
	}

	result := make([]string, 0, 2)
	result = append(result, c.indexedTrigger.indexerFunc(baseObjectThreadUnsafe(event.Object)))
	if event.PrevObject == nil {
		return result, true
	}
	prevTriggerValue := c.indexedTrigger.indexerFunc(baseObjectThreadUnsafe(event.PrevObject))
	if result[0] != prevTriggerValue {
		result = append(result, prevTriggerValue)
	}
	return result, true
}

                                }
                              }
                            },
                            {
                              "tag": "istio.authorization.dry_run.allow_policy.result",
                              "metadata": {
                                "kind": {
                                  "request": {}
                                },
                                "metadata_key": {

	if err != nil {
		// copying the response body did not work
		t.Errorf("Cannot copy resp: %#v", err)
	}
	result := string(body)
	if !strings.Contains(result, "kubelet.log") || !strings.Contains(result, "google.log") {
		t.Errorf("Received wrong data: %s", result)
	}
}

func TestServeRunInContainer(t *testing.T) {
	fw := newServerTest()
	defer fw.testHTTPServer.Close()
	output := "foo bar"

        def sourceMainResourcePath = file('src/main/resources').getRelativePathFromBase()
        def resultsBinPath = file('build/test-results/test/binary').getRelativePathFromBase()
        result.groupedOutput.task(":outgoingVariants").assertOutputContains """--------------------------------------------------
Variant apiElements
--------------------------------------------------

      auto scast_op = rewriter.create<quantfork::StorageCastOp>(
          call_op.getLoc(), result_type, result);
      replace_map.insert(std::make_pair(result, scast_op));
    }

    for (auto replace_pair : replace_map) {
      Value result = replace_pair.first;
      quantfork::StorageCastOp scast_op = replace_pair.second;
      result.replaceAllUsesExcept(scast_op, scast_op);
    }

    // Make a copy of the quantized function.

      if (result == null) {
        entries = result = unmodifiableEntries(delegate.entries());
      }
      return result;
    }

    @Override
    public Collection<V> get(@ParametricNullness K key) {
      return unmodifiableValueCollection(delegate.get(key));
    }

    @Override
    public Multiset<K> keys() {
      Multiset<K> result = keys;
      if (result == null) {

    @Override
    public Multiset<K> keys() {
      Multiset<K> result = keys;
      if (result == null) {
        keys = result = Multisets.unmodifiableMultiset(delegate.keys());
      }
      return result;
    }

    @Override
    public Set<K> keySet() {
      Set<K> result = keySet;
      if (result == null) {
        keySet = result = Collections.unmodifiableSet(delegate.keySet());
      }

  for (Value result : return_value_from_host)
    parallel_execute_result_types.push_back(result.getType());
  for (Value result : return_value_from_device)
    parallel_execute_result_types.push_back(result.getType());
  return parallel_execute_result_types;
}

// Remap the device cluster results with parallel execute op results
llvm::SmallVector<Value, 4> GetRemappedTpuClusterResults(

        }
        try {
            final Result result = client.prepareUpdate().setIndex(index).setId(id).setDoc(field, value).execute()
                    .actionGet(ComponentUtil.getFessConfig().getIndexIndexTimeout()).getResult();
            return result == Result.CREATED || result == Result.UPDATED;
        } catch (final OpenSearchException e) {