args: args{
				n:   "foobar",
				sep: "",
			},
			want: "FOOBAR",
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := CamelCaseWithSeparator(tt.args.n, tt.args.sep); got != tt.want {
				t.Errorf("CamelCaseWithSeparator() = %v, want %v", got, tt.want)
			}
		})
	}
}

func Test_isWordSeparator(t *testing.T) {
	tests := []struct {
		name string

}

func TestParse(t *testing.T) {
	for i, tt := range constraintTests {
		t.Run(fmt.Sprint(i), func(t *testing.T) {
			x, err := Parse(tt.in)
			if err != nil {
				if tt.err == "" {
					t.Errorf("Constraint(%q): unexpected error: %v", tt.in, err)
				} else if !strings.Contains(err.Error(), tt.err) {
					t.Errorf("Constraint(%q): error %v, want %v", tt.in, err, tt.err)
				}
				return
			}
			if tt.err != "" {

			x int32
			y int16
		}{})}, false},
		{"struct {_ int32 }", args{reflect.TypeOf(struct{ _ int32 }{})}, false},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := reflect.IsRegularMemory(tt.args.t); got != tt.want {
				t.Errorf("isRegularMemory() = %v, want %v", got, tt.want)
			}
		})
	}
}

var sinkType reflect.Type

func BenchmarkTypeForString(b *testing.B) {

			wantErr:     true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			cw := &ConfigWriter{}
			cd, _ := os.ReadFile(tt.inputFile)
			err := cw.Prime(cd)
			if cw.configDump == nil {
				if tt.wantConfigs != 0 {
					t.Errorf("wanted some configs loaded but config dump was nil")
				}
			} else if len(cw.configDump.Configs) != tt.wantConfigs {

	} {
		got := TrimFilePathPrefix(tt.s, tt.prefix)
		if got == tt.want {
			t.Logf("TrimFilePathPrefix(%q, %q) = %q", tt.s, tt.prefix, got)
		} else {
			t.Errorf("TrimFilePathPrefix(%q, %q) = %q, want %q", tt.s, tt.prefix, got, tt.want)
		}

		if HasFilePathPrefix(tt.s, tt.prefix) {
			joined := filepath.Join(tt.prefix, got)
			if clean := filepath.Clean(tt.s); joined != clean {

}

func TestIPAddrScope(t *testing.T) {
	for _, tt := range ipAddrScopeTests {
		if ok := tt.scope(tt.in); ok != tt.ok {
			t.Errorf("%s(%q) = %v, want %v", name(tt.scope), tt.in, ok, tt.ok)
		}
		ip := tt.in.To4()
		if ip == nil {
			continue
		}
		if ok := tt.scope(ip); ok != tt.ok {
			t.Errorf("%s(%q) = %v, want %v", name(tt.scope), ip, ok, tt.ok)
		}
	}
}

			a:    "chunKed", // This "K" is 'KELVIN SIGN' (\u212A)
			b:    "chunked",
			want: false,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := EqualFold(tt.a, tt.b); got != tt.want {
				t.Errorf("AsciiEqualFold(%q,%q): got %v want %v", tt.a, tt.b, got, tt.want)
			}
		})
	}
}

func TestIsPrint(t *testing.T) {
	var tests = []struct {
		name string
		in   string

	for i := range archTest {
		tt := &archTest[i]
		arch, err := OpenArchive(tt.file)
		if err != nil {
			t.Error(err)
			continue
		}
		if !reflect.DeepEqual(arch.ArchiveHeader, tt.hdr) {
			t.Errorf("open archive %s:\n\thave %#v\n\twant %#v\n", tt.file, arch.ArchiveHeader, tt.hdr)
			continue
		}

		for i, mem := range arch.Members {
			if i >= len(tt.members) {
				break
			}

			},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			gotOut := &bytes.Buffer{}
			cw := &ConfigWriter{Stdout: gotOut}
			cd, _ := os.ReadFile("testdata/endpoint/configdump.json")
			cw.Prime(cd)
			err := cw.PrintEndpointsSummary(tt.filter)
			assert.NoError(t, err)

			wantOutputFile := path.Join("testdata/endpoint", fmt.Sprintf("%s_output.txt", tt.name))

						}
					} else if tt.gomodErr != "" {
						t.Errorf("repo.GoMod(%q) = %q, want error %q", tt.version, data, tt.gomodErr)
					} else if string(data) != tt.gomod {
						t.Errorf("repo.GoMod(%q) = %q, want %q", tt.version, data, tt.gomod)
					}
				}

				needHash := !testing.Short() && (tt.zipFileHash != "" || tt.zipSum != "")
				if tt.zip != nil || tt.zipErr != "" || needHash {