classpath.entries.find { it.path == 'containerPath' }.entryAttributes.customKey = 'customValue'
                       }
                   }
               }
           }
        """

        when:
        EclipseProject project = loadToolingModel(EclipseProject)
        def container = project.classpathContainers.find { it.path == 'containerPath' }

        then:

            .assertHasCause("""Could not find group:projectA:1.2.
Searched in the following locations:
  - ${module.pom.uri}
Required by:
    project :""")

        when:
        module.pom.expectGetMissing()

        then:
        fails("showMissing")
        failure.assertResolutionFailure(':missing')
            .assertHasCause("""Could not find group:projectA:1.2.
Searched in the following locations:

    int64_t tensor_id = tensor_stack.back();
    tensor_stack.pop_back();
    auto op_id_it = tensor_tape.find(tensor_id);
    if (op_id_it == tensor_tape.end()) {
      continue;
    }
    int64_t op_id = op_id_it->second;
    auto op_it = op_tape->find(op_id);
    auto result_op_it = result.op_tape.find(op_id);
    if (op_id == -1 || op_it == op_tape->end() ||
        result_op_it != result.op_tape.end()) {

        FileFilter filter = { it != excludedFile }

        when:
        def result = new SingleDepthFilesFinder(1).find(tmpDir.getTestDirectory(), filter)

        then:
        result as List == [includedFile]
    }

    def "handles empty dir"() {
        when:
        def result = new SingleDepthFilesFinder(1).find(tmpDir.getTestDirectory(), { true })

        then:
        result as List == []
    }

  - Tool chain 'gcc' (GNU GCC):
      - Could not find C++ compiler 'g++'. Searched in:
          - ${file('gcc-bin')}
  - Tool chain 'clang' (Clang):
      - Could not find C++ compiler 'clang++'. Searched in:
          - ${file('clang-bin')}""")
        } else {

        }

        private Node getBuildConfiguration() {
            projectXml.PropertyGroup.find({ it.'@Label' == 'NMakeConfiguration' && it.'@Condition' == condition}) as Node
        }

        private Node getConfiguration() {
            projectXml.PropertyGroup.find({ it.'@Label' == 'Configuration' && it.'@Condition' == condition}) as Node
        }

        private String getCondition() {

     *
     * @return The matching item if exactly 1 match found, null if no matches or multiple matches.
     * @see #find(String, Collection)
     */
    public <T> T find(String pattern, Map<String, ? extends T> items) {
        String name = find(pattern, items.keySet());
        if (name != null) {
            return items.get(name);
        }
        return null;
    }

    /**

        ExternalDependency coolLib = libs.find { it.file.name == 'coolLib-2.0.jar' }
        assert coolLib.gradleModuleVersion
        assert coolLib.gradleModuleVersion.group == 'foo.bar'
        assert coolLib.gradleModuleVersion.name == 'coolLib'
        assert coolLib.gradleModuleVersion.version == '2.0'

        ExternalDependency funLib = libs.find { it.file.name.contains('funLib') }

        then:
        assert model.taskSelectors.find { it.name == 't1' }.description == 'T1 from root'
        assert model.taskSelectors.find { it.name == 't2' }.description == null
        assert model.taskSelectors.find { it.name == 't3' }.description == 'T3 from child'
        assert model.taskSelectors.find { it.name == 't4' }.description == 'T4 from grand child 1'
    }

      if (curr.is_exiting) {
        if (node_map.find(curr.n) == node_map.end()) {
          Node* copy = g->CopyNode(curr.n);
          if (curr.n != start_node) {
            for (const Edge* e : curr.n->in_edges()) {
              auto node_iter = node_map.find(e->src());
              if (node_iter == node_map.end()) {
                return errors::Internal("Cannot find node image for ",