given:
        sourceFile << """
            #define HEADER_NAME "hello.h"
            #define _NAME do not use this
            #define HEADER HEADER ## _NAME // replaced with HEADER_NAME then "hello.h"
            #include HEADER
        """

        expect:
        resolve() == [header]
    }

	deleted := sets.New(resp.RemovedResources...)
	byName := map[string]*discovery.Resource{}
	for _, v := range resp.Resources {
		byName[v.Name] = v
	}
	res := model.Resources{}
	for _, m := range message {
		if deleted.Contains(m.Name) {
			continue
		}
		if replaced := byName[m.Name]; replaced != nil {
			res = append(res, replaced)
			delete(byName, m.Name)
			continue
		}
		res = append(res, m)
	}

			res[i] = Name(i + 1)
		}
		return res
	default:
		return []Name{name}
	}
}

// Mask returns the type as mask.
// Compound "All" types are expanded.
func (name Name) Mask() uint64 {
	if name < objectSingleTypesEnd {
		return 1 << (name - 1)
	}
	var mask uint64
	for _, n := range name.Expand() {
		mask |= 1 << (n - 1)
	}
	return mask
}

    override
    fun asName(): String =
        "${type.displayName} - ${os.asName()}${if (withoutDependencies) " without dependencies" else ""}"

    override
    fun channel() =
        "${type.channel}${if (os == Os.LINUX) "" else "-${os.name.lowercase(Locale.US)}"}-%teamcity.build.branch%"
}

data class FlameGraphGeneration(
    private val uuid: Int,
    private val name: String,

		ex.dies = append(ex.dies, entry)
		if _, found := ex.idxByOffset[entry.Offset]; found {
			return errors.New("DIE clash on offset")
		}
		ex.idxByOffset[entry.Offset] = idx
		if name, ok := entry.Val(dwarf.AttrName).(string); ok {
			ex.byname[name] = append(ex.byname[name], idx)
		}
		if len(nesting) > 0 {
			parent := nesting[len(nesting)-1]
			ex.kids[parent] = append(ex.kids[parent], idx)
			ex.parent[idx] = parent
		}

        }
        this.name = name.toUpperCase();
        this.hexCode = hexCode;
        this.scope = scope != null && scope.length() > 0 ? scope : cfg.getNetbiosScope();
        this.srcHashCode = 0;
    }


    /**
     * @param cfg
     * @param name
     */
    public Name ( Configuration cfg, NetbiosName name ) {
        this.config = cfg;
        this.name = name.getName();

    // calls our constructor and it's not easy to pass arguments to it.
    private SortPolicy sortPolicy;
    public PBXGroup(String name, @Nullable String path, SourceTree sourceTree) {
        super(name, path, sourceTree);

        sortPolicy = SortPolicy.BY_NAME;
        children = new ArrayList<>();

        childGroupsByName = CacheBuilder.newBuilder().build(
            new CacheLoader<String, PBXGroup>() {

void BM_NAME(benchmark::State& state) {
  Eigen::ThreadPool pool(port::MaxParallelism());
  Eigen::ThreadPoolDevice device(&pool, pool.NumThreads());

  CPP_CLASS computation;
  computation.set_thread_pool(&device);
  zero_buffers(&computation);

  for (auto s : state) {
    computation.Run();
  }
}
BENCHMARK(BM_NAME);

}  // namespace
}  // namespace tfcompile

abstract class AdHocPerformanceScenario(os: Os, arch: Arch = Arch.AMD64) : BuildType({
    val id = "Util_Performance_AdHocPerformanceScenario${os.asName()}${arch.asName()}"
    name = "AdHoc Performance Scenario - ${os.asName()} ${arch.asName()}"
    id(id)

    applyPerformanceTestSettings(os = os, arch = arch, timeout = 420)
    artifactRules = individualPerformanceTestArtifactRules

    params {

          {
            "matcher": {
              "id": "byName",
              "options": "Time"
            },
            "properties": [
              {
                "id": "custom.hidden",
                "value": true
              }
            ]
          },
          {
            "matcher": {
              "id": "byName",
              "options": "Value #A"
            },