{"Pid", unsafe.Offsetof(si.Pid), ofPid},
		{"Uid", unsafe.Offsetof(si.Uid), ofUid},
		{"Status", unsafe.Offsetof(si.Status), ofStatus},
	}

	for _, tc := range offsets {
		if int(tc.got) != tc.want {
			t.Errorf("offsetof %s: got %d, want %d", tc.name, tc.got, tc.want)
		}
	}

			expectedVal: celtypes.True,
		},
	} {
		t.Run(tc.name, func(t *testing.T) {
			_, option := NewTypeProviderAndEnvOption(&mockTypeResolverForOptional{
				mockTypeResolver: &mockTypeResolver{},
			})
			env := mustCreateEnvWithOptional(t, option)
			ast, issues := env.Compile(tc.expression)
			if issues != nil {
				if tc.expectedCompileError == "" {

			expectedErrMsg: "unable to add process counter: foo. Error code is c0000bc0",
		},
	}

	for name, tc := range testCases {
		t.Run(name, func(t *testing.T) {
			counter, err := newPerfCounter(tc.counter)
			if tc.expectErr {
				if err == nil || err.Error() != tc.expectedErrMsg {
					t.Fatalf("expected error message `%s` but got `%v`", tc.expectedErrMsg, err)
				}
				return
			}

func TestListGroups(t *testing.T) {
	for _, tc := range listGroupsTests {
		u := &User{Username: tc.user, Gid: tc.gid}
		got, err := listGroupsFromReader(u, strings.NewReader(tc.in))
		if tc.err {
			if err == nil {
				t.Errorf("listGroups(%q): got nil; want error", tc.user)
			}
			continue // no more checks
		}
		if err != nil {
			t.Errorf("listGroups(%q): got %v error, want nil", tc.user, err)
			continue // no more checks
		}

			expectedErr: errLifecycleDateNotMidnight,
		},
	}

	for i, tc := range testCases {
		t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) {
			var expiration Expiration
			err := xml.Unmarshal([]byte(tc.inputXML), &expiration)
			if err != tc.expectedErr {
				t.Fatalf("%d: Expected %v but got %v", i+1, tc.expectedErr, err)
			}
		})
	}

	validationTestCases := []struct {
		inputXML    string

		},
	} {
		encModes := tc.modes
		if len(encModes) == 0 {
			encModes = allEncModes
		}

		for _, encMode := range encModes {
			modeName, ok := encModeNames[encMode]
			if !ok {
				t.Fatal("test case configured to run against unrecognized mode")
			}

			t.Run(fmt.Sprintf("mode=%s/%s", modeName, tc.name), func(t *testing.T) {
				out, err := encMode.Marshal(tc.in)
				tc.assertOnError(t, err)

				}
				if err.Error() != invocation.expected.error.Error() {
					t.Errorf("(call %d of %d) expected error %q, got %q", i+1, len(tc.calls), invocation.expected.error.Error(), err.Error())
				}
			}

			if len(tc.backend) > misses {
				t.Errorf("expected %d backend invocations, got %d", len(tc.backend), misses)
			}
		})
	}

				},
			},
			expectedVersion: "metadata-version",
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			ret := SetIstioVersion(tc.meta)
			if ret.IstioVersion != tc.expectedVersion {
				t.Fatalf("SetIstioVersion: expected '%s', got '%s'", tc.expectedVersion, ret.IstioVersion)
			}
		})
	}
}

func TestConvertNodeMetadata(t *testing.T) {

	} {
		b, err := hex.DecodeString(tc.list)
		if err != nil {
			t.Fatal(err)
		}
		configs, err := parseECHConfigList(b)
		if err != nil {
			t.Fatal(err)
		}
		if len(configs) != tc.numConfigs {
			t.Fatalf("unexpected number of configs parsed: got %d want %d", len(configs), tc.numConfigs)
		}
	}

}

func TestSkipBadConfigs(t *testing.T) {

			n:      2,
			chunks: [][]int{{1, 2}, {3, 4}, {5}},
		},
	}

	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			var chunks [][]int
			for c := range Chunk(tc.s, tc.n) {
				chunks = append(chunks, c)
			}

			if !chunkEqual(chunks, tc.chunks) {
				t.Errorf("Chunk(%v, %d) = %v, want %v", tc.s, tc.n, chunks, tc.chunks)
			}

			if len(chunks) == 0 {
				return
			}