}

        @Override
        public boolean contains(Object o) {
            return asSet.contains(o);
        }

        @Override
        public boolean containsAll(Collection<?> c) {
            return asSet.containsAll(c);
        }

        @Override
        public int size() {
            return size;
        }
    }

    }

    @Test
    public void testHashCode() {
        assert createCompositeSpec(spec1).hashCode() == createCompositeSpec(spec1).hashCode();
        assert createCompositeSpec(spec1).hashCode() != createCompositeSpec(spec2).hashCode();

        assert createCompositeSpec(spec1, spec2).hashCode() == createCompositeSpec(spec1, spec2).hashCode();

                doLast {
                    assert System.getProperty("org.gradle.logging.level") == "${logLevel}"
                    assert LogLevel.${logLevel.toUpperCase()} == logLevel
                    logger.${logLevel} '${message}'
                    assert logger.${logLevel}Enabled
                    if ('${nextLevel}') {
                        assert !logger.${nextLevel}Enabled
                    }
                }

    }

    protected void assertNoOperation() {
        assert buildOperationRunner.log.records.empty
    }

    protected <T, R> void assertSuccessfulOperation(Class<BuildOperationType<T, R>> operationType, String displayName, R result) {
        withOnlyOperation(operationType) {
            assert it.descriptor.displayName == displayName
            assert it.result == result
        }
    }

                assert elementFromFileWalker != null
                assert element.directory == elementFromFileWalker.directory
                assert maybeRoundLastModified(element.lastModified) == maybeRoundLastModified(elementFromFileWalker.lastModified)
                assert element.size == elementFromFileWalker.size
                assert element.name == elementFromFileWalker.name

            BigDecimal createBigDecimal() {
                return 123
            }
        })

        expect:
        10.times {
            start {
                assert registry.get(String) == "12"
                assert registry.get(Long) == 123
            }
        }
    }

    def "multiple threads can locate factories"() {
        def registry = new DefaultServiceRegistry()

        then:
        successInvoked
    }

    def "failed or else processes failure"() {
        def failure = new RuntimeException("failure")
        boolean failureInvoked = false
        when:
        Try.failure(failure).ifSuccessfulOrElse({ assert false }, { failureInvoked = true; assert it == failure })
        then:

            def changes = delegateContext.changes.get()
            assert delegateContext.rebuildReasons == ImmutableList.of("Forced rebuild.")
            assert !changes.createInputChanges().incremental
            return delegateResult
        }
        _ * context.nonIncrementalReason >> Optional.of("Forced rebuild.")

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.cc.impl

import org.junit.Assert
import org.junit.Assert.assertFalse
import org.junit.Assert.assertTrue
import org.junit.Test
import java.lang.IllegalStateException
import java.util.concurrent.Executors


class InputTrackingStateTest {

    @Test

                @Inject abstract ProjectLayout getLayout()

                @TaskAction
                void useIt() {
                    assert foo.files == layout.files("file1", "file2").files
                    assert foo.files.size() == 2
                }
            }
            tasks.register("mytask", MyTask) {
                conventionMapping.map("foo") { bar }