Add test case for uint type

cover_uint_test.go

@@ -17,6 +17,9 @@ func TestCoverUint(t *testing.T) {
 	type structUintString struct {
 		A uint `json:"a,string"`
 	}
+	type structUintStringOmitEmpty struct {
+		A uint `json:"a,string,omitempty"`
+	}
 
 	type structUintPtr struct {
 		A *uint `json:"a"`
@@ -27,6 +30,9 @@ func TestCoverUint(t *testing.T) {
 	type structUintPtrString struct {
 		A *uint `json:"a,string"`
 	}
+	type structUintPtrStringOmitEmpty struct {
+		A *uint `json:"a,string,omitempty"`
+	}
 
 	tests := []struct {
 		name string
@@ -72,6 +78,12 @@ func TestCoverUint(t *testing.T) {
 				A uint `json:"a,string"`
 			}{},
 		},
+		{
+			name: "HeadUintZeroStringOmitEmpty",
+			data: struct {
+				A uint `json:"a,string,omitempty"`
+			}{},
+		},
 
 		// HeadUint
 		{
@@ -92,6 +104,12 @@ func TestCoverUint(t *testing.T) {
 				A uint `json:"a,string"`
 			}{A: 1},
 		},
+		{
+			name: "HeadUintStringOmitEmpty",
+			data: struct {
+				A uint `json:"a,string,omitempty"`
+			}{A: 1},
+		},
 
 		// HeadUintPtr
 		{
@@ -112,6 +130,12 @@ func TestCoverUint(t *testing.T) {
 				A *uint `json:"a,string"`
 			}{A: uptr(1)},
 		},
+		{
+			name: "HeadUintPtrStringOmitEmpty",
+			data: struct {
+				A *uint `json:"a,string,omitempty"`
+			}{A: uptr(1)},
+		},
 
 		// HeadUintPtrNil
 		{
@@ -132,6 +156,12 @@ func TestCoverUint(t *testing.T) {
 				A *uint `json:"a,string"`
 			}{A: nil},
 		},
+		{
+			name: "HeadUintPtrNilStringOmitEmpty",
+			data: struct {
+				A *uint `json:"a,string,omitempty"`
+			}{A: nil},
+		},
 
 		// PtrHeadUintZero
 		{
@@ -152,6 +182,12 @@ func TestCoverUint(t *testing.T) {
 				A uint `json:"a,string"`
 			}{},
 		},
+		{
+			name: "PtrHeadUintZeroStringOmitEmpty",
+			data: &struct {
+				A uint `json:"a,string,omitempty"`
+			}{},
+		},
 
 		// PtrHeadUint
 		{
@@ -172,6 +208,12 @@ func TestCoverUint(t *testing.T) {
 				A uint `json:"a,string"`
 			}{A: 1},
 		},
+		{
+			name: "PtrHeadUintStringOmitEmpty",
+			data: &struct {
+				A uint `json:"a,string,omitempty"`
+			}{A: 1},
+		},
 
 		// PtrHeadUintPtr
 		{
@@ -192,6 +234,12 @@ func TestCoverUint(t *testing.T) {
 				A *uint `json:"a,string"`
 			}{A: uptr(1)},
 		},
+		{
+			name: "PtrHeadUintPtrStringOmitEmpty",
+			data: &struct {
+				A *uint `json:"a,string,omitempty"`
+			}{A: uptr(1)},
+		},
 
 		// PtrHeadUintPtrNil
 		{
@@ -212,6 +260,12 @@ func TestCoverUint(t *testing.T) {
 				A *uint `json:"a,string"`
 			}{A: nil},
 		},
+		{
+			name: "PtrHeadUintPtrNilStringOmitEmpty",
+			data: &struct {
+				A *uint `json:"a,string,omitempty"`
+			}{A: nil},
+		},
 
 		// PtrHeadUintNil
 		{
@@ -232,6 +286,12 @@ func TestCoverUint(t *testing.T) {
 				A *uint `json:"a,string"`
 			})(nil),
 		},
+		{
+			name: "PtrHeadUintNilStringOmitEmpty",
+			data: (*struct {
+				A *uint `json:"a,string,omitempty"`
+			})(nil),
+		},
 
 		// HeadUintZeroMultiFields
 		{
@@ -251,13 +311,21 @@ func TestCoverUint(t *testing.T) {
 			}{},
 		},
 		{
-			name: "HeadUintZeroMultiFields",
+			name: "HeadUintZeroMultiFieldsString",
 			data: struct {
 				A uint `json:"a,string"`
 				B uint `json:"b,string"`
 				C uint `json:"c,string"`
 			}{},
 		},
+		{
+			name: "HeadUintZeroMultiFieldsStringOmitEmpty",
+			data: struct {
+				A uint `json:"a,string,omitempty"`
+				B uint `json:"b,string,omitempty"`
+				C uint `json:"c,string,omitempty"`
+			}{},
+		},
 
 		// HeadUintMultiFields
 		{
@@ -284,6 +352,14 @@ func TestCoverUint(t *testing.T) {
 				C uint `json:"c,string"`
 			}{A: 1, B: 2, C: 3},
 		},
+		{
+			name: "HeadUintMultiFieldsStringOmitEmpty",
+			data: struct {
+				A uint `json:"a,string,omitempty"`
+				B uint `json:"b,string,omitempty"`
+				C uint `json:"c,string,omitempty"`
+			}{A: 1, B: 2, C: 3},
+		},
 
 		// HeadUintPtrMultiFields
 		{
@@ -310,6 +386,14 @@ func TestCoverUint(t *testing.T) {
 				C *uint `json:"c,string"`
 			}{A: uptr(1), B: uptr(2), C: uptr(3)},
 		},
+		{
+			name: "HeadUintPtrMultiFieldsStringOmitEmpty",
+			data: struct {
+				A *uint `json:"a,string,omitempty"`
+				B *uint `json:"b,string,omitempty"`
+				C *uint `json:"c,string,omitempty"`
+			}{A: uptr(1), B: uptr(2), C: uptr(3)},
+		},
 
 		// HeadUintPtrNilMultiFields
 		{
@@ -336,6 +420,14 @@ func TestCoverUint(t *testing.T) {
 				C *uint `json:"c,string"`
 			}{A: nil, B: nil, C: nil},
 		},
+		{
+			name: "HeadUintPtrNilMultiFieldsStringOmitEmpty",
+			data: struct {
+				A *uint `json:"a,string,omitempty"`
+				B *uint `json:"b,string,omitempty"`
+				C *uint `json:"c,string,omitempty"`
+			}{A: nil, B: nil, C: nil},
+		},
 
 		// PtrHeadUintZeroMultiFields
 		{
@@ -359,6 +451,13 @@ func TestCoverUint(t *testing.T) {
 				B uint `json:"b,string"`
 			}{},
 		},
+		{
+			name: "PtrHeadUintZeroMultiFieldsStringOmitEmpty",
+			data: &struct {
+				A uint `json:"a,string,omitempty"`
+				B uint `json:"b,string,omitempty"`
+			}{},
+		},
 
 		// PtrHeadUintMultiFields
 		{
@@ -382,6 +481,13 @@ func TestCoverUint(t *testing.T) {
 				B uint `json:"b,string"`
 			}{A: 1, B: 2},
 		},
+		{
+			name: "PtrHeadUintMultiFieldsStringOmitEmpty",
+			data: &struct {
+				A uint `json:"a,string,omitempty"`
+				B uint `json:"b,string,omitempty"`
+			}{A: 1, B: 2},
+		},
 
 		// PtrHeadUintPtrMultiFields
 		{
@@ -405,6 +511,13 @@ func TestCoverUint(t *testing.T) {
 				B *uint `json:"b,string"`
 			}{A: uptr(1), B: uptr(2)},
 		},
+		{
+			name: "PtrHeadUintPtrMultiFieldsStringOmitEmpty",
+			data: &struct {
+				A *uint `json:"a,string,omitempty"`
+				B *uint `json:"b,string,omitempty"`
+			}{A: uptr(1), B: uptr(2)},
+		},
 
 		// PtrHeadUintPtrNilMultiFields
 		{
@@ -428,6 +541,13 @@ func TestCoverUint(t *testing.T) {
 				B *uint `json:"b,string"`
 			}{A: nil, B: nil},
 		},
+		{
+			name: "PtrHeadUintPtrNilMultiFieldsStringOmitEmpty",
+			data: &struct {
+				A *uint `json:"a,string,omitempty"`
+				B *uint `json:"b,string,omitempty"`
+			}{A: nil, B: nil},
+		},
 
 		// PtrHeadUintNilMultiFields
 		{
@@ -451,6 +571,13 @@ func TestCoverUint(t *testing.T) {
 				B *uint `json:"b,string"`
 			})(nil),
 		},
+		{
+			name: "PtrHeadUintNilMultiFieldsStringOmitEmpty",
+			data: (*struct {
+				A *uint `json:"a,string,omitempty"`
+				B *uint `json:"b,string,omitempty"`
+			})(nil),
+		},
 
 		// HeadUintZeroNotRoot
 		{
@@ -477,6 +604,14 @@ func TestCoverUint(t *testing.T) {
 				}
 			}{},
 		},
+		{
+			name: "HeadUintZeroNotRootStringOmitEmpty",
+			data: struct {
+				A struct {
+					A uint `json:"a,string,omitempty"`
+				}
+			}{},
+		},
 
 		// HeadUintNotRoot
 		{
@@ -509,6 +644,16 @@ func TestCoverUint(t *testing.T) {
 				A uint `json:"a,string"`
 			}{A: 1}},
 		},
+		{
+			name: "HeadUintNotRootStringOmitEmpty",
+			data: struct {
+				A struct {
+					A uint `json:"a,string,omitempty"`
+				}
+			}{A: struct {
+				A uint `json:"a,string,omitempty"`
+			}{A: 1}},
+		},
 
 		// HeadUintPtrNotRoot
 		{
@@ -541,6 +686,16 @@ func TestCoverUint(t *testing.T) {
 				A *uint `json:"a,string"`
 			}{uptr(1)}},
 		},
+		{
+			name: "HeadUintPtrNotRootStringOmitEmpty",
+			data: struct {
+				A struct {
+					A *uint `json:"a,string,omitempty"`
+				}
+			}{A: struct {
+				A *uint `json:"a,string,omitempty"`
+			}{uptr(1)}},
+		},
 
 		// HeadUintPtrNilNotRoot
 		{
@@ -567,6 +722,14 @@ func TestCoverUint(t *testing.T) {
 				}
 			}{},
 		},
+		{
+			name: "HeadUintPtrNilNotRootStringOmitEmpty",
+			data: struct {
+				A struct {
+					A *uint `json:"a,string,omitempty"`
+				}
+			}{},
+		},
 
 		// PtrHeadUintZeroNotRoot
 		{
@@ -599,6 +762,16 @@ func TestCoverUint(t *testing.T) {
 				A uint `json:"a,string"`
 			})},
 		},
+		{
+			name: "PtrHeadUintZeroNotRootStringOmitEmpty",
+			data: struct {
+				A *struct {
+					A uint `json:"a,string,omitempty"`
+				}
+			}{A: new(struct {
+				A uint `json:"a,string,omitempty"`
+			})},
+		},
 
 		// PtrHeadUintNotRoot
 		{
@@ -631,6 +804,16 @@ func TestCoverUint(t *testing.T) {
 				A uint `json:"a,string"`
 			}{A: 1})},
 		},
+		{
+			name: "PtrHeadUintNotRootStringOmitEmpty",
+			data: struct {
+				A *struct {
+					A uint `json:"a,string,omitempty"`
+				}
+			}{A: &(struct {
+				A uint `json:"a,string,omitempty"`
+			}{A: 1})},
+		},
 
 		// PtrHeadUintPtrNotRoot
 		{
@@ -663,6 +846,16 @@ func TestCoverUint(t *testing.T) {
 				A *uint `json:"a,string"`
 			}{A: uptr(1)})},
 		},
+		{
+			name: "PtrHeadUintPtrNotRootStringOmitEmpty",
+			data: struct {
+				A *struct {
+					A *uint `json:"a,string,omitempty"`
+				}
+			}{A: &(struct {
+				A *uint `json:"a,string,omitempty"`
+			}{A: uptr(1)})},
+		},
 
 		// PtrHeadUintPtrNilNotRoot
 		{
@@ -695,6 +888,16 @@ func TestCoverUint(t *testing.T) {
 				A *uint `json:"a,string"`
 			}{A: nil})},
 		},
+		{
+			name: "PtrHeadUintPtrNilNotRootStringOmitEmpty",
+			data: struct {
+				A *struct {
+					A *uint `json:"a,string,omitempty"`
+				}
+			}{A: &(struct {
+				A *uint `json:"a,string,omitempty"`
+			}{A: nil})},
+		},
 
 		// PtrHeadUintNilNotRoot
 		{
@@ -721,6 +924,14 @@ func TestCoverUint(t *testing.T) {
 				} `json:",string"`
 			}{A: nil},
 		},
+		{
+			name: "PtrHeadUintNilNotRootStringOmitEmpty",
+			data: struct {
+				A *struct {
+					A *uint `json:"a,string,omitempty"`
+				} `json:",string,omitempty"`
+			}{A: nil},
+		},
 
 		// HeadUintZeroMultiFieldsNotRoot
 		{
@@ -756,6 +967,17 @@ func TestCoverUint(t *testing.T) {
 				}
 			}{},
 		},
+		{
+			name: "HeadUintZeroMultiFieldsNotRootStringOmitEmpty",
+			data: struct {
+				A struct {
+					A uint `json:"a,string,omitempty"`
+				}
+				B struct {
+					B uint `json:"b,string,omitempty"`
+				}
+			}{},
+		},
 
 		// HeadUintMultiFieldsNotRoot
 		{
@@ -803,6 +1025,21 @@ func TestCoverUint(t *testing.T) {
 				B uint `json:"b,string"`
 			}{B: 2}},
 		},
+		{
+			name: "HeadUintMultiFieldsNotRootStringOmitEmpty",
+			data: struct {
+				A struct {
+					A uint `json:"a,string,omitempty"`
+				}
+				B struct {
+					B uint `json:"b,string,omitempty"`
+				}
+			}{A: struct {
+				A uint `json:"a,string,omitempty"`
+			}{A: 1}, B: struct {
+				B uint `json:"b,string,omitempty"`
+			}{B: 2}},
+		},
 
 		// HeadUintPtrMultiFieldsNotRoot
 		{
@@ -850,6 +1087,21 @@ func TestCoverUint(t *testing.T) {
 				B *uint `json:"b,string"`
 			}{B: uptr(2)}},
 		},
+		{
+			name: "HeadUintPtrMultiFieldsNotRootStringOmitEmpty",
+			data: struct {
+				A struct {
+					A *uint `json:"a,string,omitempty"`
+				}
+				B struct {
+					B *uint `json:"b,string,omitempty"`
+				}
+			}{A: struct {
+				A *uint `json:"a,string,omitempty"`
+			}{A: uptr(1)}, B: struct {
+				B *uint `json:"b,string,omitempty"`
+			}{B: uptr(2)}},
+		},
 
 		// HeadUintPtrNilMultiFieldsNotRoot
 		{
@@ -897,6 +1149,21 @@ func TestCoverUint(t *testing.T) {
 				B *uint `json:"b,string"`
 			}{B: nil}},
 		},
+		{
+			name: "HeadUintPtrNilMultiFieldsNotRootStringOmitEmpty",
+			data: struct {
+				A struct {
+					A *uint `json:"a,string,omitempty"`
+				}
+				B struct {
+					B *uint `json:"b,string,omitempty"`
+				}
+			}{A: struct {
+				A *uint `json:"a,string,omitempty"`
+			}{A: nil}, B: struct {
+				B *uint `json:"b,string,omitempty"`
+			}{B: nil}},
+		},
 
 		// PtrHeadUintZeroMultiFieldsNotRoot
 		{
@@ -932,6 +1199,17 @@ func TestCoverUint(t *testing.T) {
 				}
 			}{},
 		},
+		{
+			name: "PtrHeadUintZeroMultiFieldsNotRootStringOmitEmpty",
+			data: &struct {
+				A struct {
+					A uint `json:"a,string,omitempty"`
+				}
+				B struct {
+					B uint `json:"b,string,omitempty"`
+				}
+			}{},
+		},
 
 		// PtrHeadUintMultiFieldsNotRoot
 		{
@@ -979,6 +1257,21 @@ func TestCoverUint(t *testing.T) {
 				B uint `json:"b,string"`
 			}{B: 2}},
 		},
+		{
+			name: "PtrHeadUintMultiFieldsNotRootStringOmitEmpty",
+			data: &struct {
+				A struct {
+					A uint `json:"a,string,omitempty"`
+				}
+				B struct {
+					B uint `json:"b,string,omitempty"`
+				}
+			}{A: struct {
+				A uint `json:"a,string,omitempty"`
+			}{A: 1}, B: struct {
+				B uint `json:"b,string,omitempty"`
+			}{B: 2}},
+		},
 
 		// PtrHeadUintPtrMultiFieldsNotRoot
 		{
@@ -1026,6 +1319,21 @@ func TestCoverUint(t *testing.T) {
 				B *uint `json:"b,string"`
 			}{B: uptr(2)})},
 		},
+		{
+			name: "PtrHeadUintPtrMultiFieldsNotRootStringOmitEmpty",
+			data: &struct {
+				A *struct {
+					A *uint `json:"a,string,omitempty"`
+				}
+				B *struct {
+					B *uint `json:"b,string,omitempty"`
+				}
+			}{A: &(struct {
+				A *uint `json:"a,string,omitempty"`
+			}{A: uptr(1)}), B: &(struct {
+				B *uint `json:"b,string,omitempty"`
+			}{B: uptr(2)})},
+		},
 
 		// PtrHeadUintPtrNilMultiFieldsNotRoot
 		{
@@ -1061,6 +1369,17 @@ func TestCoverUint(t *testing.T) {
 				} `json:",string"`
 			}{A: nil, B: nil},
 		},
+		{
+			name: "PtrHeadUintPtrNilMultiFieldsNotRootStringOmitEmpty",
+			data: &struct {
+				A *struct {
+					A *uint `json:"a,string,omitempty"`
+				} `json:",string,omitempty"`
+				B *struct {
+					B *uint `json:"b,string,omitempty"`
+				} `json:",string,omitempty"`
+			}{A: nil, B: nil},
+		},
 
 		// PtrHeadUintNilMultiFieldsNotRoot
 		{
@@ -1096,6 +1415,17 @@ func TestCoverUint(t *testing.T) {
 				}
 			})(nil),
 		},
+		{
+			name: "PtrHeadUintNilMultiFieldsNotRootStringOmitEmpty",
+			data: (*struct {
+				A *struct {
+					A *uint `json:"a,string,omitempty"`
+				}
+				B *struct {
+					B *uint `json:"b,string,omitempty"`
+				}
+			})(nil),
+		},
 
 		// PtrHeadUintDoubleMultiFieldsNotRoot
 		{
@@ -1155,6 +1485,25 @@ func TestCoverUint(t *testing.T) {
 				B uint `json:"b,string"`
 			}{A: 3, B: 4})},
 		},
+		{
+			name: "PtrHeadUintDoubleMultiFieldsNotRootStringOmitEmpty",
+			data: &struct {
+				A *struct {
+					A uint `json:"a,string,omitempty"`
+					B uint `json:"b,string,omitempty"`
+				}
+				B *struct {
+					A uint `json:"a,string,omitempty"`
+					B uint `json:"b,string,omitempty"`
+				}
+			}{A: &(struct {
+				A uint `json:"a,string,omitempty"`
+				B uint `json:"b,string,omitempty"`
+			}{A: 1, B: 2}), B: &(struct {
+				A uint `json:"a,string,omitempty"`
+				B uint `json:"b,string,omitempty"`
+			}{A: 3, B: 4})},
+		},
 
 		// PtrHeadUintNilDoubleMultiFieldsNotRoot
 		{
@@ -1196,6 +1545,19 @@ func TestCoverUint(t *testing.T) {
 				}
 			}{A: nil, B: nil},
 		},
+		{
+			name: "PtrHeadUintNilDoubleMultiFieldsNotRootStringOmitEmpty",
+			data: &struct {
+				A *struct {
+					A uint `json:"a,string,omitempty"`
+					B uint `json:"b,string,omitempty"`
+				}
+				B *struct {
+					A uint `json:"a,string,omitempty"`
+					B uint `json:"b,string,omitempty"`
+				}
+			}{A: nil, B: nil},
+		},
 
 		// PtrHeadUintNilDoubleMultiFieldsNotRoot
 		{
@@ -1237,6 +1599,19 @@ func TestCoverUint(t *testing.T) {
 				}
 			})(nil),
 		},
+		{
+			name: "PtrHeadUintNilDoubleMultiFieldsNotRootStringOmitEmpty",
+			data: (*struct {
+				A *struct {
+					A uint `json:"a,string,omitempty"`
+					B uint `json:"b,string,omitempty"`
+				}
+				B *struct {
+					A uint `json:"a,string,omitempty"`
+					B uint `json:"b,string,omitempty"`
+				}
+			})(nil),
+		},
 
 		// PtrHeadUintPtrDoubleMultiFieldsNotRoot
 		{
@@ -1296,6 +1671,25 @@ func TestCoverUint(t *testing.T) {
 				B *uint `json:"b,string"`
 			}{A: uptr(3), B: uptr(4)})},
 		},
+		{
+			name: "PtrHeadUintPtrDoubleMultiFieldsNotRootStringOmitEmpty",
+			data: &struct {
+				A *struct {
+					A *uint `json:"a,string,omitempty"`
+					B *uint `json:"b,string,omitempty"`
+				}
+				B *struct {
+					A *uint `json:"a,string,omitempty"`
+					B *uint `json:"b,string,omitempty"`
+				}
+			}{A: &(struct {
+				A *uint `json:"a,string,omitempty"`
+				B *uint `json:"b,string,omitempty"`
+			}{A: uptr(1), B: uptr(2)}), B: &(struct {
+				A *uint `json:"a,string,omitempty"`
+				B *uint `json:"b,string,omitempty"`
+			}{A: uptr(3), B: uptr(4)})},
+		},
 
 		// PtrHeadUintPtrNilDoubleMultiFieldsNotRoot
 		{
@@ -1337,6 +1731,19 @@ func TestCoverUint(t *testing.T) {
 				}
 			}{A: nil, B: nil},
 		},
+		{
+			name: "PtrHeadUintPtrNilDoubleMultiFieldsNotRootStringOmitEmpty",
+			data: &struct {
+				A *struct {
+					A *uint `json:"a,string,omitempty"`
+					B *uint `json:"b,string,omitempty"`
+				}
+				B *struct {
+					A *uint `json:"a,string,omitempty"`
+					B *uint `json:"b,string,omitempty"`
+				}
+			}{A: nil, B: nil},
+		},
 
 		// PtrHeadUintPtrNilDoubleMultiFieldsNotRoot
 		{
@@ -1378,6 +1785,19 @@ func TestCoverUint(t *testing.T) {
 				}
 			})(nil),
 		},
+		{
+			name: "PtrHeadUintPtrNilDoubleMultiFieldsNotRootStringOmitEmpty",
+			data: (*struct {
+				A *struct {
+					A *uint `json:"a,string,omitempty"`
+					B *uint `json:"b,string,omitempty"`
+				}
+				B *struct {
+					A *uint `json:"a,string,omitempty"`
+					B *uint `json:"b,string,omitempty"`
+				}
+			})(nil),
+		},
 
 		// AnonymousHeadUint
 		{
@@ -1410,6 +1830,16 @@ func TestCoverUint(t *testing.T) {
 				B:                2,
 			},
 		},
+		{
+			name: "AnonymousHeadUintStringOmitEmpty",
+			data: struct {
+				structUintStringOmitEmpty
+				B uint `json:"b,string,omitempty"`
+			}{
+				structUintStringOmitEmpty: structUintStringOmitEmpty{A: 1},
+				B:                         2,
+			},
+		},
 
 		// PtrAnonymousHeadUint
 		{
@@ -1442,6 +1872,16 @@ func TestCoverUint(t *testing.T) {
 				B:                2,
 			},
 		},
+		{
+			name: "PtrAnonymousHeadUintStringOmitEmpty",
+			data: struct {
+				*structUintStringOmitEmpty
+				B uint `json:"b,string,omitempty"`
+			}{
+				structUintStringOmitEmpty: &structUintStringOmitEmpty{A: 1},
+				B:                         2,
+			},
+		},
 
 		// NilPtrAnonymousHeadUint
 		{
@@ -1474,6 +1914,16 @@ func TestCoverUint(t *testing.T) {
 				B:                2,
 			},
 		},
+		{
+			name: "NilPtrAnonymousHeadUintStringOmitEmpty",
+			data: struct {
+				*structUintStringOmitEmpty
+				B uint `json:"b,string,omitempty"`
+			}{
+				structUintStringOmitEmpty: nil,
+				B:                         2,
+			},
+		},
 
 		// AnonymousHeadUintPtr
 		{
@@ -1506,6 +1956,16 @@ func TestCoverUint(t *testing.T) {
 				B:                   uptr(2),
 			},
 		},
+		{
+			name: "AnonymousHeadUintPtrStringOmitEmpty",
+			data: struct {
+				structUintPtrStringOmitEmpty
+				B *uint `json:"b,string,omitempty"`
+			}{
+				structUintPtrStringOmitEmpty: structUintPtrStringOmitEmpty{A: uptr(1)},
+				B:                            uptr(2),
+			},
+		},
 
 		// AnonymousHeadUintPtrNil
 		{
@@ -1538,6 +1998,16 @@ func TestCoverUint(t *testing.T) {
 				B:                   uptr(2),
 			},
 		},
+		{
+			name: "AnonymousHeadUintPtrNilStringOmitEmpty",
+			data: struct {
+				structUintPtrStringOmitEmpty
+				B *uint `json:"b,string,omitempty"`
+			}{
+				structUintPtrStringOmitEmpty: structUintPtrStringOmitEmpty{A: nil},
+				B:                            uptr(2),
+			},
+		},
 
 		// PtrAnonymousHeadUintPtr
 		{
@@ -1570,6 +2040,16 @@ func TestCoverUint(t *testing.T) {
 				B:                   uptr(2),
 			},
 		},
+		{
+			name: "PtrAnonymousHeadUintPtrStringOmitEmpty",
+			data: struct {
+				*structUintPtrStringOmitEmpty
+				B *uint `json:"b,string,omitempty"`
+			}{
+				structUintPtrStringOmitEmpty: &structUintPtrStringOmitEmpty{A: uptr(1)},
+				B:                            uptr(2),
+			},
+		},
 
 		// NilPtrAnonymousHeadUintPtr
 		{
@@ -1602,6 +2082,16 @@ func TestCoverUint(t *testing.T) {
 				B:                   uptr(2),
 			},
 		},
+		{
+			name: "NilPtrAnonymousHeadUintPtrStringOmitEmpty",
+			data: struct {
+				*structUintPtrStringOmitEmpty
+				B *uint `json:"b,string,omitempty"`
+			}{
+				structUintPtrStringOmitEmpty: nil,
+				B:                            uptr(2),
+			},
+		},
 
 		// AnonymousHeadUintOnly
 		{
@@ -1628,6 +2118,14 @@ func TestCoverUint(t *testing.T) {
 				structUintString: structUintString{A: 1},
 			},
 		},
+		{
+			name: "AnonymousHeadUintOnlyStringOmitEmpty",
+			data: struct {
+				structUintStringOmitEmpty
+			}{
+				structUintStringOmitEmpty: structUintStringOmitEmpty{A: 1},
+			},
+		},
 
 		// PtrAnonymousHeadUintOnly
 		{
@@ -1654,6 +2152,14 @@ func TestCoverUint(t *testing.T) {
 				structUintString: &structUintString{A: 1},
 			},
 		},
+		{
+			name: "PtrAnonymousHeadUintOnlyStringOmitEmpty",
+			data: struct {
+				*structUintStringOmitEmpty
+			}{
+				structUintStringOmitEmpty: &structUintStringOmitEmpty{A: 1},
+			},
+		},
 
 		// NilPtrAnonymousHeadUintOnly
 		{
@@ -1680,6 +2186,14 @@ func TestCoverUint(t *testing.T) {
 				structUintString: nil,
 			},
 		},
+		{
+			name: "NilPtrAnonymousHeadUintOnlyStringOmitEmpty",
+			data: struct {
+				*structUintStringOmitEmpty
+			}{
+				structUintStringOmitEmpty: nil,
+			},
+		},
 
 		// AnonymousHeadUintPtrOnly
 		{
@@ -1706,6 +2220,14 @@ func TestCoverUint(t *testing.T) {
 				structUintPtrString: structUintPtrString{A: uptr(1)},
 			},
 		},
+		{
+			name: "AnonymousHeadUintPtrOnlyStringOmitEmpty",
+			data: struct {
+				structUintPtrStringOmitEmpty
+			}{
+				structUintPtrStringOmitEmpty: structUintPtrStringOmitEmpty{A: uptr(1)},
+			},
+		},
 
 		// AnonymousHeadUintPtrNilOnly
 		{
@@ -1732,6 +2254,14 @@ func TestCoverUint(t *testing.T) {
 				structUintPtrString: structUintPtrString{A: nil},
 			},
 		},
+		{
+			name: "AnonymousHeadUintPtrNilOnlyStringOmitEmpty",
+			data: struct {
+				structUintPtrStringOmitEmpty
+			}{
+				structUintPtrStringOmitEmpty: structUintPtrStringOmitEmpty{A: nil},
+			},
+		},
 
 		// PtrAnonymousHeadUintPtrOnly
 		{
@@ -1758,6 +2288,14 @@ func TestCoverUint(t *testing.T) {
 				structUintPtrString: &structUintPtrString{A: uptr(1)},
 			},
 		},
+		{
+			name: "PtrAnonymousHeadUintPtrOnlyStringOmitEmpty",
+			data: struct {
+				*structUintPtrStringOmitEmpty
+			}{
+				structUintPtrStringOmitEmpty: &structUintPtrStringOmitEmpty{A: uptr(1)},
+			},
+		},
 
 		// NilPtrAnonymousHeadUintPtrOnly
 		{
@@ -1784,6 +2322,14 @@ func TestCoverUint(t *testing.T) {
 				structUintPtrString: nil,
 			},
 		},
+		{
+			name: "NilPtrAnonymousHeadUintPtrOnlyStringOmitEmpty",
+			data: struct {
+				*structUintPtrStringOmitEmpty
+			}{
+				structUintPtrStringOmitEmpty: nil,
+			},
+		},
 	}
 	for _, test := range tests {
 		for _, indent := range []bool{true, false} {