}
	testenv.MustHaveGoBuild(t)

	defer func() {
		if x := recover(); x != nil {
			t.Errorf("expected no panic; recovered %v", x)
		}
	}()
	for _, context := range contexts {
		w := NewWalker(context, "testdata/src/issue64958")
		pkg, err := w.importFrom("p", "", 0)
		if err != nil {
			t.Errorf("expected no error importing; got %T", err)
		}
		w.export(pkg)
	}
}

func TestCheck(t *testing.T) {

  }

  private static void assertHash32(
      int expected, ImmutableSupplier<Checksum> supplier, String input) {
    byte[] bytes = HashTestUtils.ascii(input);
    String toString = "name";
    HashFunction func = new ChecksumHashFunction(supplier, 32, toString);
    assertEquals(expected, func.hashBytes(bytes).asInt());
    assertThat(func.toString()).isEqualTo(toString);
  }

        File file = new File(dir, filename);

        if (shouldExist) {
            assertTrue(file.exists(), "Expected " + file + ".exists() to return true");
        } else {
            assertFalse(file.exists(), "Expected " + file + ".exists() to return false");
        }
    }

    private void assertArrayEquals(String[] expected, String[] actual) {
        java.util.Arrays.sort(expected);
        java.util.Arrays.sort(actual);
        assertEquals(expected.length, actual.length);
        for (int i = 0; i < expected.length; i++) {
            assertEquals(expected[i], actual[i]);
        }
    }

    void toString_rendersHex(byte[] input, String expected) {
        // Arrange
        SecurityBlob blob = new SecurityBlob(input);

        // Act
        String actual = blob.toString();

        // Assert
        assertEquals(expected, actual, "Hex string should match expected format");
    }

    // Ensures a default-constructed blob starts empty and stable across APIs

	}

	for k := range expectedMap {
		if v, ok := res.Header[k]; !ok {
			c.Errorf("Expected key %s missing from %v", k, res.Header)
		} else {
			expectedSet := set.CreateStringSet(expectedMap[k]...)
			gotSet := set.CreateStringSet(strings.Split(v[0], ", ")...)
			if !expectedSet.Equals(gotSet) {
				c.Errorf("Expected value %v, got %v", strings.Join(expectedMap[k], ", "), v)
			}
		}
	}
}

var ErrInvalidChecksum = errors.New("invalid checksum")

// SetExpectedMin set expected minimum data expected from reader
func (r *Reader) SetExpectedMin(expectedMin int64) {
	r.expectedMin = expectedMin
}

// SetExpectedMax set expected max data expected from reader
func (r *Reader) SetExpectedMax(expectedMax int64) {
	r.expectedMax = expectedMax
}

name: Bug Report
description: Something is not working as expected
labels: ["type=defect"]
body:
  - type: markdown
    attributes:
      value: >
        Thank you for filing a bug report. Please help us identify and resolve the bug by filling
        out the following fields. Before we begin, please make sure that the bug is still present in
        the [latest](https://github.com/google/guava/releases/latest) version of Guava available.

          }
        };
    Thread runner = new Thread(task);
    runner.start();
    isInterruptibleRegistered.await();
    RuntimeException expected = assertThrows(RuntimeException.class, task::interruptTask);
    assertThat(expected)
        .hasMessageThat()
        .isEqualTo("I bet you didn't think Thread.interrupt could throw");
    /*

          }
        };
    Thread runner = new Thread(task);
    runner.start();
    isInterruptibleRegistered.await();
    RuntimeException expected = assertThrows(RuntimeException.class, task::interruptTask);
    assertThat(expected)
        .hasMessageThat()
        .isEqualTo("I bet you didn't think Thread.interrupt could throw");
    /*