# How to use NaN method of td Package

Best Go-testdeep code snippet using td.NaN

interpol8_test.go

Source:interpol8_test.go

`...124type tt struct {125 in []RawPoint126 out []IntPoint127}128// Fill an []IntPoints "expected" array with NaNs so we don't have to type so much129func resNaNFill(r []IntPoint) []IntPoint {130 if len(r) < count {131 extra := make([]IntPoint, count-len(r))132 for i := range extra {133 nan := math.NaN()134 extra[i] = IntPoint{start, nan, nan, nan}135 }136 // if what we have starts with {0,0,0} we prepend NaNs, else append137 if len(r) > 0 && r[0].Avg == 0 {138 nan := math.NaN()139 r[0] = IntPoint{start, nan, nan, nan}140 r = append(extra, r...)141 } else {142 r = append(r, extra...)143 }144 }145 // set all the timestamps146 for i := 1; i < len(r); i += 1 {147 r[i].Asof = r[0].Asof + uint64(i*step)148 }149 return r150}151// Format IntPoints so we can easily cut&paste into expected152// out: "[]IntPoints{ { 1, 1, 2 }, { 2, 2, 3 }, { 3, 3, 3 } } },"153func fmtInt(int []IntPoint) (str string) {154 str = fmt.Sprintf("[%d]IntPoint{ ", len(int))155 wasNaN := false156 for _, v := range int {157 if false && math.IsNaN(v.Avg) {158 if !wasNaN {159 str += "NaN... "160 }161 wasNaN = true162 } else {163 str += fmt.Sprint("{", v.Asof, ",", v.Avg, ",", v.Min, ",", v.Max, "}, ")164 wasNaN = false165 }166 }167 str += " }"168 return169}170func resEqual(a1, a2 []IntPoint) bool {171 if len(a1) != len(a2) {172 return false173 }174 for i := range a1 {175 v1 := a1[i]176 v2 := a2[i]177 //fmt.Println("Comparing", v1, v2, "->", (math.Abs(v1.Avg-v2.Avg) > 0.001),178 // math.IsNaN(v1.Avg), math.IsNaN(v2.Avg))179 if v1.Asof != v2.Asof {180 return false181 }182 if math.Abs(v1.Avg-v2.Avg) > 0.001 || math.IsNaN(v1.Avg) != math.IsNaN(v2.Avg) {183 return false184 }185 if math.Abs(v1.Min-v2.Min) > 0.001 || math.IsNaN(v1.Min) != math.IsNaN(v2.Min) {186 return false187 }188 if math.Abs(v1.Max-v2.Max) > 0.001 || math.IsNaN(v1.Max) != math.IsNaN(v2.Max) {189 return false190 }191 }192 return true193}194//===== Tests for interpolation of rates =====195// Test cases for interpolating rate data196const s = start197const e = start + count*step198var rateTests = []tt{199 {in: []RawPoint{{s + 0, 10}, {s + 20, 20}, {s + 30, 30}, {s + 50, 40}, {s + 100, 90}},200 out: []IntPoint{{s, 0.5, 0.5, 0.5}, {s, 0.75, 0.5, 1}, {s, 0.75, 0.5, 1}, {s, 1, 1, 1}, {s, 1, 1, 1}}},201 // tests using a single raw point202 {in: []RawPoint{{s - 10, 1}}, out: []IntPoint{}},203 {in: []RawPoint{{s + 0, 1}}, out: []IntPoint{}},204 {in: []RawPoint{{s + 10, 1}}, out: []IntPoint{}},205 {in: []RawPoint{{s + 20, 1}}, out: []IntPoint{}},206 {in: []RawPoint{{s + 30, 1}}, out: []IntPoint{}},207 {in: []RawPoint{{s + 1000, 1}}, out: []IntPoint{}},208 {in: []RawPoint{{s + 1010, 1}}, out: []IntPoint{}},209 // tests using two raw points210 {in: []RawPoint{{s - 10, 0}, {s + 0, 20}}, out: []IntPoint{}},211 {in: []RawPoint{{s - 10, 0}, {s + 10, 20}},212 out: []IntPoint{{s, 1, 1, 1}}},213 {in: []RawPoint{{s - 20, 0}, {s + 20, 20}},214 out: []IntPoint{{s, 0.5, 0.5, 0.5}}},215 {in: []RawPoint{{s - 20, 0}, {s + 30, 25}},216 out: []IntPoint{{s, 0.5, 0.5, 0.5}, {s, 0.5, 0.5, 0.5}}},217 {in: []RawPoint{{s - 20, 0}, {s + 40, 60}},218 out: []IntPoint{{s, 1, 1, 1}, {s, 1, 1, 1}}},219 {in: []RawPoint{{s - 20, 0}, {s + 100, 20}}, out: []IntPoint{}},220 {in: []RawPoint{{s + 1000, 0}, {s + 1010, 20}}, out: []IntPoint{{}}},221 {in: []RawPoint{{e - 10, 0}, {e + 10, 20}},222 out: []IntPoint{{s, 0, 0, 0}, {s, 1, 1, 1}}},223 {in: []RawPoint{{e - 20, 0}, {e + 10, 60}},224 out: []IntPoint{{s, 0, 0, 0}, {s, 2, 2, 2}}},225 // tests using three raw points226 {in: []RawPoint{{s - 10, 0}, {s + 10, 20}, {s + 30, 60}},227 out: []IntPoint{{s, 1.5, 1, 2}, {s, 2, 2, 2}}},228}229func TestInterpolateRate(t *testing.T) {230 for i := range rateTests {231 // fill output with NaN and set times232 exp := resNaNFill(rateTests[i].out)233 // run the interpolation234 res, err := Raw(rateTests[i].in, Rate, start, start+count*step, step, 4*step)235 // shouldn't have gotten any error236 if err != nil {237 t.Fatal("Test", i, "unexpected error:", err)238 }239 // test we got the right result240 if !resEqual(res, exp) {241 t.Error("Test", i, "failed!\nInput:\n", rateTests[i].in,242 "\nOutput:\n", fmtInt(res), "\nExpected:\n", fmtInt(exp))243 }244 }245}246//===== Tests for interpolation of absolute data =====247// Test cases for interpolating absolute data248var absTests = []tt{249 {in: []RawPoint{{s + 0, 1}, {s + 20, 2}, {s + 30, 3}, {s + 50, 4}, {s + 100, 9}},250 out: []IntPoint{251 {s, 1.5, 1, 2}, {s, 2.875, 2, 3.5}, {s, 4.125, 3.5, 5},252 {s, 6, 5, 7}, {s, 8, 7, 9}, {s, 9, 9, 9}},253 },254 // tests using a single raw point255 {in: []RawPoint{{s + -10, 1}}, out: []IntPoint{}},256 {in: []RawPoint{{s + 0, 1}},257 out: []IntPoint{{s, 1, 1, 1}}},258 {in: []RawPoint{{s + 10, 1}},259 out: []IntPoint{{s, 1, 1, 1}}},260 {in: []RawPoint{{s + 20, 1}},261 out: []IntPoint{{s, math.NaN(), math.NaN(), math.NaN()}, {s, 1, 1, 1}}},262 {in: []RawPoint{{s + 30, 1}},263 out: []IntPoint{{s, math.NaN(), math.NaN(), math.NaN()}, {s, 1, 1, 1}}},264 {in: []RawPoint{{e + 0, 1}}, out: []IntPoint{}},265 {in: []RawPoint{{e + 10, 1}}, out: []IntPoint{}},266 // tests using two raw points267 {in: []RawPoint{{s + -10, 1}, {s + 0, 2}},268 out: []IntPoint{{s, 2, 2, 2}}},269 {in: []RawPoint{{s + -10, 1}, {s + 10, 2}},270 out: []IntPoint{{s, 1.75, 1.5, 2}}},271 {in: []RawPoint{{s + -20, 1}, {s + 20, 2}},272 out: []IntPoint{{s, 1.75, 1.5, 2}, {s, 2, 2, 2}}},273 {in: []RawPoint{{s + -20, 1}, {s + 40, 4}},274 out: []IntPoint{{s, 2.5, 2, 3}, {s, 3.5, 3, 4}, {s, 4, 4, 4}}},275 {in: []RawPoint{{s + -20, 1}, {s + 100, 2}},276 out: []IntPoint{277 {s, math.NaN(), math.NaN(), math.NaN()},278 {s, math.NaN(), math.NaN(), math.NaN()},279 {s, math.NaN(), math.NaN(), math.NaN()},280 {s, math.NaN(), math.NaN(), math.NaN()},281 {s, math.NaN(), math.NaN(), math.NaN()}, {s, 2, 2, 2}},282 },283 {in: []RawPoint{{e + 0, 1}, {e + 10, 2}}, out: []IntPoint{}},284 {in: []RawPoint{{e + -10, 1}, {e + 10, 2}},285 out: []IntPoint{{s, 0, 0, 0}, {s, 1.25, 1, 1.5}}},286 {in: []RawPoint{{e + -20, 1}, {e + 10, 4}},287 out: []IntPoint{{s, 0, 0, 0}, {s, 2, 1, 3}}},288 {in: []RawPoint{}, out: []IntPoint{}},289}290func TestInterpolateAbs(t *testing.T) {291 for i := range absTests {292 // fill output with NaN and set times293 exp := resNaNFill(absTests[i].out)294 // run the interpolation295 res, err := Raw(absTests[i].in, Absolute, start, start+count*step, step, 4*step)296 // shouldn't have gotten any error297 if err != nil {298 t.Fatal("Test", i, "unexpected error:", err)299 }300 // test we got the right result301 if !resEqual(res, exp) {302 t.Error("Test", i, "failed!\nInput:\n", absTests[i].in,303 "\nOutput:\n", fmtInt(res), "\nExpected:\n", fmtInt(exp))304 }305 }306}...`

atan2_test.go

Source:atan2_test.go

`...36 Y: math.Pi,37 WantZ: (math.Pi / 2),38 WantErr: nil,39 },40 // [3], y > 0, x == NaN :41 &atan2TestType{42 FuncMkWantZ: func(td *atan2TestType) {43 td.WantErr = errors.Errorf(44 "X is not <, > or equal to 0.0. x:=\"%d\"\n\n", td.X)45 },46 WantZ: math.NaN(),47 X: math.NaN(),48 Y: math.Pi,49 },50 // [4], y < 0, x > 0 :51 &atan2TestType{52 FuncMkWantZ: func(td *atan2TestType) {53 td.WantZ = (-1 * math.Atan((-td.Y / td.X)))54 },55 X: math.Pi,56 Y: -1.0 * math.Pi,57 WantErr: nil,58 },59 // [5], y < 0, x < 0 :60 &atan2TestType{61 FuncMkWantZ: func(td *atan2TestType) {62 td.WantZ = (math.Atan((td.X / td.Y)) - math.Pi)63 },64 X: -1.0 * math.Pi,65 Y: -1.0 * math.Pi,66 WantErr: nil,67 },68 // [6], y < 0, x == 0 :69 &atan2TestType{70 X: 0.0,71 Y: -1.0 * math.Pi,72 WantZ: ((3 * math.Pi) / 2),73 WantErr: nil,74 },75 // [7], y < 0, x == NaN :76 &atan2TestType{77 FuncMkWantZ: func(td *atan2TestType) {78 td.WantErr = errors.Errorf(79 "X is not <, > or equal to 0.0. x:=\"%d\"\n\n", td.X)80 },81 X: math.NaN(),82 Y: -1.0 * math.Pi,83 WantZ: math.NaN(),84 WantErr: nil,85 },86 // [8], y == 0, x > 0 :87 &atan2TestType{88 X: math.Pi,89 Y: 0.0,90 WantZ: 0.0,91 WantErr: nil,92 },93 // [9], y == 0, x < 0 :94 &atan2TestType{95 X: -1.0 * math.Pi,96 Y: 0.0,97 WantZ: math.Pi,98 WantErr: nil,99 },100 // [10], y == 0, x == 0 :101 &atan2TestType{102 X: 0.0,103 Y: 0.0,104 WantZ: math.NaN(),105 WantErr: ErrSameLocation,106 },107 // [11], y == 0, x == NaN :108 &atan2TestType{109 FuncMkWantZ: func(td *atan2TestType) {110 td.WantErr = errors.Errorf("%s. x:=\"%v\"",111 "X is not <, > or equal to 0.0", td.X)112 },113 X: math.NaN(),114 Y: 0.0,115 WantZ: math.NaN(),116 },117 // [12], y == ?, x == ? :118 &atan2TestType{119 FuncMkWantZ: func(td *atan2TestType) {120 td.WantErr = errors.Errorf("%s x:=\"%v\", y:=\"%v\"",121 "X,Y is not <, > or equal to 0.0.", td.X, td.Y)122 },123 X: math.NaN(),124 Y: math.NaN(),125 WantZ: math.NaN(),126 },127}128func TestAtan2(t *testing.T) {129 var (130 gotZ float64131 gotErr error132 s string133 ok bool134 )135 for i, td := range atan2TestTable {136 if td.FuncMkWantZ != nil {137 td.FuncMkWantZ(td)138 }139 gotZ, gotErr = atan2(td.X, td.Y)...`

td_nan_test.go

Source:td_nan_test.go

`...8 "math"9 "testing"10 "github.com/maxatome/go-testdeep/td"11)12func TestNaN(t *testing.T) {13 checkOK(t, math.NaN(), td.NaN())14 checkOK(t, float32(math.NaN()), td.NaN())15 checkError(t, float32(12), td.NaN(),16 expectedError{17 Message: mustBe("values differ"),18 Path: mustBe("DATA"),19 Got: mustBe("(float32) 12"),20 Expected: mustBe("NaN"),21 })22 checkError(t, float64(12), td.NaN(),23 expectedError{24 Message: mustBe("values differ"),25 Path: mustBe("DATA"),26 Got: mustBe("12.0"),27 Expected: mustBe("NaN"),28 })29 checkError(t, 12, td.NaN(),30 expectedError{31 Message: mustBe("type mismatch"),32 Path: mustBe("DATA"),33 Got: mustBe("int"),34 Expected: mustBe("float32 OR float64"),35 })36}37func TestNotNaN(t *testing.T) {38 checkOK(t, float64(12), td.NotNaN())39 checkOK(t, float32(12), td.NotNaN())40 checkError(t, float32(math.NaN()), td.NotNaN(),41 expectedError{42 Message: mustBe("values differ"),43 Path: mustBe("DATA"),44 Got: mustBe("(float32) NaN"),45 Expected: mustBe("not NaN"),46 })47 checkError(t, math.NaN(), td.NotNaN(),48 expectedError{49 Message: mustBe("values differ"),50 Path: mustBe("DATA"),51 Got: mustBe("NaN"),52 Expected: mustBe("not NaN"),53 })54 checkError(t, 12, td.NotNaN(),55 expectedError{56 Message: mustBe("type mismatch"),57 Path: mustBe("DATA"),58 Got: mustBe("int"),59 Expected: mustBe("float32 OR float64"),60 })61}62func TestNaNTypeBehind(t *testing.T) {63 equalTypes(t, td.NaN(), nil)64 equalTypes(t, td.NotNaN(), nil)65}...`

NaN

Using AI Code Generation

`1import (2func main() {3 var f float64 = math.NaN()4}5import (6func main() {7 var f float64 = math.NaN()8}9import (10func main() {11 var f float64 = math.NaN()12}13import (14func main() {15 var f float64 = math.NaN()16}17import (18func main() {19 var f float64 = math.NaN()20}21import (22func main() {23 var f float64 = math.NaN()24}25import (26func main() {27 var f float64 = math.NaN()28}29import (30func main() {31 var f float64 = math.NaN()32}33import (34func main() {`

NaN

Using AI Code Generation

`1import (2func main() {3 fmt.Println(td.NaN())4}5import (6func main() {7 fmt.Println(td.NaN())8}9import (10func main() {11 fmt.Println(td.NaN())12}13import (14func main() {15 fmt.Println(td.NaN())16}17import (18func main() {19 fmt.Println(td.NaN())20}21import (22func main() {23 fmt.Println(td.NaN())24}25import (26func main() {27 fmt.Println(td.NaN())28}29import (30func main() {31 fmt.Println(td.NaN())32}33import (34func main() {35 fmt.Println(td.NaN())36}37import (38func main() {39 fmt.Println(td.NaN())40}41import (42func main() {43 fmt.Println(td.NaN())44}45import (46func main() {47 fmt.Println(td.NaN())`

NaN

Using AI Code Generation

`1import (2func main() {3 fmt.Println(math.NaN())4}5import (6func main() {7 fmt.Println(math.IsNaN(math.NaN()))8}9import (10func main() {11 fmt.Println(math.IsNaN(math.Inf(1)))12}13import (14func main() {15 fmt.Println(math.IsNaN(math.Inf(-1)))16}17import (18func main() {19 fmt.Println(math.IsNaN(0))20}21import (22func main() {23 fmt.Println(math.IsNaN(1))24}25import (26func main() {27 fmt.Println(math.IsNaN(0.1))28}29import (30func main() {31 fmt.Println(math.IsNaN(-0.1))32}33import (34func main() {35 fmt.Println(math.IsNaN(1.1))36}37import (38func main() {39 fmt.Println(math.IsNaN(-1.1))40}`

NaN

Using AI Code Generation

`1import (2func main() {3 x = math.NaN()4 fmt.Println(x == x, x < x, x > x)5}6import (7func main() {8 x = math.NaN()9 fmt.Println(math.IsNaN(x))10}11import (12func main() {13 x = math.NaN()14 fmt.Println(math.IsNaN(x))15}16import (17func main() {18 x = math.NaN()19 fmt.Println(math.IsNaN(x))20}21import (22func main() {23 x = math.NaN()24 fmt.Println(math.IsNaN(x))25}26import (27func main() {28 x = math.NaN()29 fmt.Println(math.IsNaN(x))30}31import (32func main() {33 x = math.NaN()34 fmt.Println(math.IsNaN(x))35}36import (37func main() {38 x = math.NaN()39 fmt.Println(math.IsNaN(x))40}41import (42func main() {43 x = math.NaN()44 fmt.Println(math.IsNaN(x))45}46import (47func main() {48 x = math.NaN()49 fmt.Println(math.IsNaN(x))50}51import`

NaN

Using AI Code Generation

`1import (2func main() {3 fmt.Println(math.NaN())4}5Example 3: math.NaN() in Golang6import (7func main() {8 fmt.Println(math.IsNaN(math.NaN()))9}10Example 4: math.NaN() in Golang11import (12func main() {13 fmt.Println(math.IsNaN(1))14}15Example 5: math.NaN() in Golang16import (17func main() {18 fmt.Println(math.IsNaN(0))19}20Example 6: math.NaN() in Golang21import (22func main() {23 fmt.Println(math.IsNaN(math.Inf(1)))24}25Example 7: math.NaN() in Golang26import (27func main() {28 fmt.Println(math.IsNaN(math.Inf(-1)))29}30Example 8: math.NaN() in Golang31import (32func main() {33 fmt.Println(math.IsNaN(math.MaxFloat64))34}35Example 9: math.NaN() in Golang36import (37func main() {38 fmt.Println(math.IsNaN(math.SmallestNonzeroFloat64))39}40Example 10: math.NaN() in Golang41import (`

NaN

Using AI Code Generation

`1import (2func main() {3 fmt.Println(math.NaN())4}5Example 3: NaN() method of math package6import (7func main() {8 fmt.Println(math.NaN())9}10Example 4: NaN() method of math package11import (12func main() {13 fmt.Println(math.NaN())14}15Example 5: NaN() method of math package16import (17func main() {18 fmt.Println(math.NaN())19}20Example 6: NaN() method of math package21import (22func main() {23 fmt.Println(math.NaN())24}25Example 7: NaN() method of math package26import (27func main() {28 fmt.Println(math.NaN())29}30Example 8: NaN() method of math package31import (32func main() {33 fmt.Println(math.NaN())34}35Example 9: NaN() method of math package36import (37func main() {38 fmt.Println(math.NaN())39}40Example 10: NaN() method of math package41import (42func main() {43 fmt.Println(math.NaN())44}45Example 11: NaN() method of math package46import (`

NaN

Using AI Code Generation

`1import (2func main() {3 fmt.Println(math.NaN() == math.NaN())4 fmt.Println(math.NaN() != math.NaN())5 fmt.Println(math.NaN() < math.NaN())6 fmt.Println(math.NaN() > math.NaN())7 fmt.Println(math.NaN() <= math.NaN())8 fmt.Println(math.NaN() >= math.NaN())9}10import (11func main() {12 fmt.Println(math.NaN() == math.NaN())13 fmt.Println(math.NaN() != math.NaN())14 fmt.Println(math.NaN() < math.NaN())15 fmt.Println(math.NaN() > math.NaN())16 fmt.Println(math.NaN() <= math.NaN())17 fmt.Println(math.NaN() >= math.NaN())18}19import (20func main() {21 fmt.Println(time.Now().Nanosecond() == time.Now().Nanosecond())22 fmt.Println(time.Now().Nanosecond() != time.Now().Nanosecond())23 fmt.Println(time.Now().Nanosecond() < time.Now().Nanosecond())24 fmt.Println(time.Now().Nanosecond() > time.Now().Nanosecond())25 fmt.Println(time.Now().Nanosecond() <= time.Now().Nanosecond())26 fmt.Println(time.Now().Nanosecond() >= time.Now().Nanosecond())27}28import (29func main() {30 fmt.Println(strings.Compare("abc", "abc") == strings.Compare("abc", "abc"))31 fmt.Println(strings`

NaN

Using AI Code Generation

`1import (2func main() {3 fmt.Println(math.NaN())4}5import (6func main() {7 fmt.Println(math.IsNaN(math.NaN()))8}9import (10func main() {11 fmt.Println(math.IsInf(math.Inf(1), 1))12}13import (14func main() {15 fmt.Println(math.IsInf(math.Inf(-1), -1))16}17import (18func main() {19 fmt.Println(math.IsInf(math.Inf(0), 1))20}21import (22func main() {23 fmt.Println(math.IsInf(math.Inf(0), -1))24}25import (26func main() {27 fmt.Println(math.IsInf(math.Inf(0), 0))28}29import (30func main() {31 fmt.Println(math.IsInf(math.Inf(0), -2))32}33import (34func main() {`

NaN

Using AI Code Generation

`1import (2func main() {3 fmt.Println(math.IsNaN(x))4 y := math.NaN()5 fmt.Println(math.IsNaN(y))6}`

## Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.