continue
			}
		}

		// If we were unable to read anything out of the archive don't
		// bother trying to roundtrip it.
		if len(files) == 0 {
			return
		}

		w := NewWriter(io.Discard)
		for _, f := range files {
			ww, err := w.CreateHeader(f.header)
			if err != nil {
				t.Fatalf("unable to write previously parsed header: %s", err)
			}

}

// Unique reports whether the column may be unique.
func (ct ColumnType) Unique() (unique bool, ok bool) {
	return ct.UniqueValue.Bool, ct.UniqueValue.Valid
}

// ScanType returns a Go type suitable for scanning into using Rows.Scan.
func (ct ColumnType) ScanType() reflect.Type {
	if ct.ScanTypeValue != nil {
		return ct.ScanTypeValue
	}
	return ct.SQLColumnType.ScanType()
}

/**
 * Immutable identifier of a {@link TransferResource}.
 * The {@link TransferResource} is not immutable and does not implement {@code Objects#equals} and {@code Objects#hashCode} methods,
 * making it not very suitable for usage in collections.
 */
record TransferResourceIdentifier(String repositoryId, String repositoryUrl, String resourceName, @Nullable File file) {
    TransferResourceIdentifier(TransferResource resource) {

        {
            "detail": [
                {
                    "type": "int_parsing",
                    "loc": ["body", "foo", "[key]"],
                    "msg": "Input should be a valid integer, unable to parse string as an integer",
                    "input": "foo",
                }
            ]
        }
    ) | IsDict(
        # TODO: remove when deprecating Pydantic v1
        {
            "detail": [

# Security Policy

## Supported Versions

We support the past two Go releases (for example, Go 1.17.x and Go 1.18.x when Go 1.18.x is the latest stable release).

See https://go.dev/wiki/Go-Release-Cycle and in particular the
[Release Maintenance](https://go.dev/wiki/Go-Release-Cycle#release-maintenance)
part of that page.

## Reporting a Vulnerability

    table.put("c", "b", "a");
    table.put("b", "b", "x");
    table.put("b", "c", "y");
    table.put("b", "x", "n");
    table.put("a", "a", "d");
    table.row("b").subMap("c", "x").clear();
    assertEquals(table.row("b"), ImmutableMap.of("b", "x", "x", "n"));
    table.row("b").subMap("b", "y").clear();
    assertEquals(table.row("b"), ImmutableMap.of());
    assertFalse(table.backingMap.containsKey("b"));
  }

		})
	}
}

func TestExtractHostPort(t *testing.T) {
	testCases := []struct {
		addr        string
		host        string
		port        string
		expectedErr error
	}{
		{"", "", "", errors.New("unable to process empty address")},
		{"localhost:9000", "localhost", "9000", nil},
		{"http://:9000/", "", "9000", nil},
		{"http://8.8.8.8:9000/", "8.8.8.8", "9000", nil},

    assertTrue(table.contains("bar", 1));
    assertTrue(table.contains("foo", 3));
    assertFalse(table.contains("foo", 2));
    assertFalse(table.contains("bar", 3));
    assertFalse(table.contains("cat", 1));
    assertFalse(table.contains("foo", null));
    assertFalse(table.contains(null, 1));
    assertFalse(table.contains(null, null));
  }

  public void testContainsRow() {

 * prevention and <i>no</i> expectation of bit dispersion. This leaves them perfectly suitable for
 * use in hash tables, because extra collisions cause only a slight performance hit, while poor bit
 * dispersion is easily corrected using a secondary hash function (which all reasonable hash table
 * implementations in Java use). For the many uses of hash functions beyond data structures,

 * prevention and <i>no</i> expectation of bit dispersion. This leaves them perfectly suitable for
 * use in hash tables, because extra collisions cause only a slight performance hit, while poor bit
 * dispersion is easily corrected using a secondary hash function (which all reasonable hash table
 * implementations in Java use). For the many uses of hash functions beyond data structures,