Back to Repositories

Testing Null Filtering and Parameter Casting Utilities in Butterknife

This test suite validates the utility functions in Butterknife’s runtime library, focusing on null filtering operations and parameter type casting. The tests ensure robust handling of null values in collections and verify proper parameter type validation.

Test Coverage Overview

The test suite provides comprehensive coverage of Butterknife’s utility functions, particularly focusing on null filtering and type casting operations.

Tests null filtering for both lists and arrays
Validates array reference preservation when no nulls present
Verifies parameter casting error handling
Covers edge cases with various null positions in collections

Implementation Analysis

The implementation utilizes JUnit’s testing framework with Google Truth assertions for enhanced readability and precise verification.

Key patterns include:

Systematic null position testing
Reference equality verification
Exception message validation
Multiple assertion combinations per test case

Technical Details

Testing infrastructure includes:

JUnit 4 testing framework
Google Truth assertion library
Butterknife internal Utils class
Static imports for streamlined test code

Best Practices Demonstrated

The test suite exemplifies several testing best practices:

Comprehensive null case coverage
Clear test method naming
Isolated test cases
Explicit failure conditions
Thorough error message validation

jakewharton/butterknife

butterknife-runtime/src/test/java/butterknife/UtilsTest.java

            
package butterknife;

import butterknife.internal.Utils;
import org.junit.Test;

import static butterknife.internal.Utils.arrayFilteringNull;
import static butterknife.internal.Utils.listFilteringNull;
import static com.google.common.truth.Truth.assertThat;
import static org.junit.Assert.fail;

public final class UtilsTest {
  @Test public void listOfFiltersNull() {
    assertThat(listFilteringNull(null, null, null)).isEmpty();
    assertThat(listFilteringNull("One", null, null)).containsExactly("One");
    assertThat(listFilteringNull(null, "One", null)).containsExactly("One");
    assertThat(listFilteringNull(null, null, "One")).containsExactly("One");
    assertThat(listFilteringNull("One", "Two", null)).containsExactly("One", "Two");
    assertThat(listFilteringNull("One", null, "Two")).containsExactly("One", "Two");
    assertThat(listFilteringNull(null, "One", "Two")).containsExactly("One", "Two");
    assertThat(listFilteringNull("One", "Two", "Three")).containsExactly("One", "Two", "Three");
  }

  @Test public void arrayFilteringNullRemovesNulls() {
    assertThat(arrayFilteringNull(null, null, null)).isEmpty();
    assertThat(arrayFilteringNull("One", null, null)).asList().containsExactly("One");
    assertThat(arrayFilteringNull(null, "One", null)).asList().containsExactly("One");
    assertThat(arrayFilteringNull(null, null, "One")).asList().containsExactly("One");
    assertThat(arrayFilteringNull("One", "Two", null)).asList().containsExactly("One", "Two");
    assertThat(arrayFilteringNull("One", null, "Two")).asList().containsExactly("One", "Two");
    assertThat(arrayFilteringNull(null, "One", "Two")).asList().containsExactly("One", "Two");
  }

  @Test public void arrayFilteringNullReturnsOriginalWhenNoNulls() {
    String[] input = { "One", "Two", "Three" };
    String[] actual = arrayFilteringNull(input);
    assertThat(actual).isSameAs(input);
    // Even though we got the same reference back check to ensure its contents weren't mutated.
    assertThat(actual).asList().containsExactly("One", "Two", "Three");
  }

  @Test public void testCastParam() {
    try {
      Utils.castParam("abc", "Foo", 3, "foo()", 4, Integer.class);
      fail();
    } catch (IllegalStateException ise) {
      assertThat(ise.getMessage()).isEqualTo(
          "Parameter #4 of method 'Foo' was of the wrong type for parameter #5 of method 'foo()'. See cause for more info.");
    }
  }
}