id("gradlebuild.build-logic.groovy-dsl-gradle-plugin")
}

description = "Provides a plugin that cleans up after executing tests"

dependencies {
    implementation("gradlebuild:basics")
    implementation("gradlebuild:module-identity")

            int result = testImpl.decode(buffer, 10, 40);

            assertEquals(0, result); // Test implementation returns 0
        }
    }

    @Nested
    @DisplayName("SmbInfoAllocation Implementation Tests")
    class SmbInfoAllocationTests {

        private SmbInfoAllocation smbInfoAllocation;

        @BeforeEach
        void setUp() {

plugins {
    `kotlin-dsl`
}

description = "Provides plugin for configuring default settings plugins"

group = "gradlebuild"

dependencies {
    implementation(buildLibs.develocityPlugin)
    implementation(buildLibs.develocityConventions)
    implementation(buildLibs.foojayConventions)

 * override {@code addAll} as well, either providing your own implementation, or delegating to the
 * provided {@code standardAddAll} method.
 *
 * <p><b>{@code default} method warning:</b> This class does <i>not</i> forward calls to {@code
 * default} methods. Instead, it inherits their default implementations. When those implementations
 * invoke methods, they invoke methods on the {@code ForwardingSet}.
 *

        }
    }

    @Nested
    @DisplayName("Implementation Tests")
    class ImplementationTests {

        @Test
        @DisplayName("Test concrete implementation of FileNotifyInformation")
        void testConcreteImplementation() {
            // Create a simple implementation for testing
            FileNotifyInformation impl = new FileNotifyInformation() {

      testProguardFiles("test-proguard-rules.pro")
    }
  }

  lint {
    abortOnError = true
  }
}

dependencies {
  implementation(libs.playservices.safetynet)
  implementation(projects.okhttp)
  implementation(libs.androidx.activity)

  androidTestImplementation(libs.androidx.junit)
  androidTestImplementation(libs.androidx.espresso.core)

          .build();

  /**
   * type → implementation. Inherently mutable interfaces and abstract classes are mapped to their
   * default implementations and are "new"d upon get().
   */
  private static final ConcurrentMap<Class<?>, Class<?>> implementations = Maps.newConcurrentMap();

  private static <T> void setImplementation(Class<T> type, Class<? extends T> implementation) {

 * override {@code addAll} as well, either providing your own implementation, or delegating to the
 * provided {@code standardAddAll} method.
 *
 * <p><b>{@code default} method warning:</b> This class does <i>not</i> forward calls to {@code
 * default} methods. Instead, it inherits their default implementations. When those implementations
 * invoke methods, they invoke methods on the {@code ForwardingSortedSet}.
 *

        @Override
        public void insertOrUpdate(JobLog entity) {
            // Mock implementation that doesn't require client
            entity.setLastUpdated(System.currentTimeMillis());
        }

        @Override
        public void insert(JobLog entity) {
            // Mock implementation that doesn't require client
            entity.setLastUpdated(System.currentTimeMillis());
        }

 */

plugins {
    `kotlin-dsl`
}

description = "Provides plugin for generating architecture documentation"

group = "gradlebuild"

dependencies {
    implementation(project(":build-environment"))
    implementation(buildLibs.gson)