diff options
author | Ondřej Surý <ondrej@sury.org> | 2011-02-14 13:23:51 +0100 |
---|---|---|
committer | Ondřej Surý <ondrej@sury.org> | 2011-02-14 13:23:51 +0100 |
commit | 758ff64c69e34965f8af5b2d6ffd65e8d7ab2150 (patch) | |
tree | 6d6b34f8c678862fe9b56c945a7b63f68502c245 /test | |
parent | 3e45412327a2654a77944249962b3652e6142299 (diff) | |
download | golang-758ff64c69e34965f8af5b2d6ffd65e8d7ab2150.tar.gz |
Imported Upstream version 2011-02-01.1upstream/2011-02-01.1
Diffstat (limited to 'test')
80 files changed, 4067 insertions, 3161 deletions
diff --git a/test/append.go b/test/append.go index 17c665227..96421c36b 100644 --- a/test/append.go +++ b/test/append.go @@ -193,7 +193,7 @@ func verifyInterface() { case 2: e[i] = fmt.Sprintf("%d", i) case 3: - e[i] = float(i) + e[i] = float64(i) } } diff --git a/test/blank.go b/test/blank.go index 6e69f8aaa..681a5e77c 100644 --- a/test/blank.go +++ b/test/blank.go @@ -28,7 +28,7 @@ const ( c4 ) -var ints = []string { +var ints = []string{ "1", "2", "3", @@ -36,15 +36,15 @@ var ints = []string { func f() (int, int) { call += "f" - return 1,2 + return 1, 2 } -func g() (float, float) { +func g() (float64, float64) { call += "g" - return 3,4 + return 3, 4 } -func h(_ int, _ float) { +func h(_ int, _ float64) { } func i() int { @@ -55,43 +55,64 @@ func i() int { var _ = i() func main() { - if call != "i" {panic("init did not run")} + if call != "i" { + panic("init did not run") + } call = "" _, _ = f() a, _ := f() - if a != 1 {panic(a)} + if a != 1 { + panic(a) + } b, _ := g() - if b != 3 {panic(b)} + if b != 3 { + panic(b) + } _, a = f() - if a != 2 {panic(a)} + if a != 2 { + panic(a) + } _, b = g() - if b != 4 {panic(b)} + if b != 4 { + panic(b) + } _ = i() - if call != "ffgfgi" {panic(call)} - if c4 != 4 {panic(c4)} + if call != "ffgfgi" { + panic(call) + } + if c4 != 4 { + panic(c4) + } out := "" for _, s := range ints { out += s } - if out != "123" {panic(out)} + if out != "123" { + panic(out) + } sum := 0 for s := range ints { sum += s } - if sum != 3 {panic(sum)} + if sum != 3 { + panic(sum) + } - h(a,b) + h(a, b) } // useless but legal var _ int = 1 var _ = 2 var _, _ = 3, 4 + const _ = 3 const _, _ = 4, 5 + type _ int + func _() { panic("oops") } diff --git a/test/chan/doubleselect.go b/test/chan/doubleselect.go index 592d2f54a..3c7412ed6 100644 --- a/test/chan/doubleselect.go +++ b/test/chan/doubleselect.go @@ -21,6 +21,8 @@ var iterations *int = flag.Int("n", 100000, "number of iterations") func sender(n int, c1, c2, c3, c4 chan<- int) { defer close(c1) defer close(c2) + defer close(c3) + defer close(c4) for i := 0; i < n; i++ { select { @@ -35,26 +37,18 @@ func sender(n int, c1, c2, c3, c4 chan<- int) { // mux receives the values from sender and forwards them onto another channel. // It would be simplier to just have sender's four cases all be the same // channel, but this doesn't actually trigger the bug. -func mux(out chan<- int, in <-chan int) { - for { - v := <-in - if closed(in) { - close(out) - break - } +func mux(out chan<- int, in <-chan int, done chan<- bool) { + for v := range in { out <- v } + done <- true } // recver gets a steam of values from the four mux's and checks for duplicates. func recver(in <-chan int) { seen := make(map[int]bool) - for { - v := <-in - if closed(in) { - break - } + for v := range in { if _, ok := seen[v]; ok { println("got duplicate value: ", v) panic("fail") @@ -70,15 +64,23 @@ func main() { c2 := make(chan int) c3 := make(chan int) c4 := make(chan int) + done := make(chan bool) cmux := make(chan int) go sender(*iterations, c1, c2, c3, c4) - go mux(cmux, c1) - go mux(cmux, c2) - go mux(cmux, c3) - go mux(cmux, c4) + go mux(cmux, c1, done) + go mux(cmux, c2, done) + go mux(cmux, c3, done) + go mux(cmux, c4, done) + go func() { + <-done + <-done + <-done + <-done + close(cmux) + }() // We keep the recver because it might catch more bugs in the future. // However, the result of the bug linked to at the top is that we'll - // end up panicing with: "throw: bad g->status in ready". + // end up panicking with: "throw: bad g->status in ready". recver(cmux) print("PASS\n") } diff --git a/test/chan/nonblock.go b/test/chan/nonblock.go index 52f04bfb1..33afb3291 100644 --- a/test/chan/nonblock.go +++ b/test/chan/nonblock.go @@ -76,7 +76,6 @@ func main() { var i64 int64 var b bool var s string - var ok bool var sync = make(chan bool) @@ -86,35 +85,45 @@ func main() { cb := make(chan bool, buffer) cs := make(chan string, buffer) - i32, ok = <-c32 - if ok { + select { + case i32 = <-c32: panic("blocked i32sender") + default: } - i64, ok = <-c64 - if ok { + select { + case i64 = <-c64: panic("blocked i64sender") + default: } - b, ok = <-cb - if ok { + select { + case b = <-cb: panic("blocked bsender") + default: } - s, ok = <-cs - if ok { + select { + case s = <-cs: panic("blocked ssender") + default: } go i32receiver(c32, sync) try := 0 - for !(c32 <- 123) { - try++ - if try > maxTries { - println("i32receiver buffer=", buffer) - panic("fail") + Send32: + for { + select { + case c32 <- 123: + break Send32 + default: + try++ + if try > maxTries { + println("i32receiver buffer=", buffer) + panic("fail") + } + sleep() } - sleep() } <-sync @@ -123,13 +132,19 @@ func main() { <-sync } try = 0 - for i32, ok = <-c32; !ok; i32, ok = <-c32 { - try++ - if try > maxTries { - println("i32sender buffer=", buffer) - panic("fail") + Recv32: + for { + select { + case i32 = <-c32: + break Recv32 + default: + try++ + if try > maxTries { + println("i32sender buffer=", buffer) + panic("fail") + } + sleep() } - sleep() } if i32 != 234 { panic("i32sender value") @@ -140,12 +155,18 @@ func main() { go i64receiver(c64, sync) try = 0 - for !(c64 <- 123456) { - try++ - if try > maxTries { - panic("i64receiver") + Send64: + for { + select { + case c64 <- 123456: + break Send64 + default: + try++ + if try > maxTries { + panic("i64receiver") + } + sleep() } - sleep() } <-sync @@ -154,12 +175,18 @@ func main() { <-sync } try = 0 - for i64, ok = <-c64; !ok; i64, ok = <-c64 { - try++ - if try > maxTries { - panic("i64sender") + Recv64: + for { + select { + case i64 = <-c64: + break Recv64 + default: + try++ + if try > maxTries { + panic("i64sender") + } + sleep() } - sleep() } if i64 != 234567 { panic("i64sender value") @@ -170,12 +197,18 @@ func main() { go breceiver(cb, sync) try = 0 - for !(cb <- true) { - try++ - if try > maxTries { - panic("breceiver") + SendBool: + for { + select { + case cb <- true: + break SendBool + default: + try++ + if try > maxTries { + panic("breceiver") + } + sleep() } - sleep() } <-sync @@ -184,12 +217,18 @@ func main() { <-sync } try = 0 - for b, ok = <-cb; !ok; b, ok = <-cb { - try++ - if try > maxTries { - panic("bsender") + RecvBool: + for { + select { + case b = <-cb: + break RecvBool + default: + try++ + if try > maxTries { + panic("bsender") + } + sleep() } - sleep() } if !b { panic("bsender value") @@ -200,12 +239,18 @@ func main() { go sreceiver(cs, sync) try = 0 - for !(cs <- "hello") { - try++ - if try > maxTries { - panic("sreceiver") + SendString: + for { + select { + case cs <- "hello": + break SendString + default: + try++ + if try > maxTries { + panic("sreceiver") + } + sleep() } - sleep() } <-sync @@ -214,12 +259,18 @@ func main() { <-sync } try = 0 - for s, ok = <-cs; !ok; s, ok = <-cs { - try++ - if try > maxTries { - panic("ssender") + RecvString: + for { + select { + case s = <-cs: + break RecvString + default: + try++ + if try > maxTries { + panic("ssender") + } + sleep() } - sleep() } if s != "hello again" { panic("ssender value") diff --git a/test/chan/perm.go b/test/chan/perm.go index d08c03519..c725829d1 100644 --- a/test/chan/perm.go +++ b/test/chan/perm.go @@ -9,49 +9,46 @@ package main var ( cr <-chan int cs chan<- int - c chan int + c chan int ) func main() { - cr = c // ok - cs = c // ok - c = cr // ERROR "illegal types|incompatible|cannot" - c = cs // ERROR "illegal types|incompatible|cannot" - cr = cs // ERROR "illegal types|incompatible|cannot" - cs = cr // ERROR "illegal types|incompatible|cannot" - - c <- 0 // ok - ok := c <- 0 // ok - _ = ok - <-c // ok - x, ok := <-c // ok - _, _ = x, ok - - cr <- 0 // ERROR "send" - ok = cr <- 0 // ERROR "send" - _ = ok - <-cr // ok - x, ok = <-cr // ok - _, _ = x, ok - - cs <- 0 // ok - ok = cs <- 0 // ok - _ = ok - <-cs // ERROR "receive" - x, ok = <-cs // ERROR "receive" - _, _ = x, ok + cr = c // ok + cs = c // ok + c = cr // ERROR "illegal types|incompatible|cannot" + c = cs // ERROR "illegal types|incompatible|cannot" + cr = cs // ERROR "illegal types|incompatible|cannot" + cs = cr // ERROR "illegal types|incompatible|cannot" + + c <- 0 // ok + <-c // ok + //TODO(rsc): uncomment when this syntax is valid for receive+check closed + // x, ok := <-c // ok + // _, _ = x, ok + + cr <- 0 // ERROR "send" + <-cr // ok + //TODO(rsc): uncomment when this syntax is valid for receive+check closed + // x, ok = <-cr // ok + // _, _ = x, ok + + cs <- 0 // ok + <-cs // ERROR "receive" + ////TODO(rsc): uncomment when this syntax is valid for receive+check closed + //// x, ok = <-cs // ERROR "receive" + //// _, _ = x, ok select { - case c <- 0: // ok - case x := <-c: // ok + case c <- 0: // ok + case x := <-c: // ok _ = x - case cr <- 0: // ERROR "send" - case x := <-cr: // ok + case cr <- 0: // ERROR "send" + case x := <-cr: // ok _ = x - case cs <- 0: // ok - case x := <-cs: // ERROR "receive" + case cs <- 0: // ok + case x := <-cs: // ERROR "receive" _ = x } } diff --git a/test/chan/select3.go b/test/chan/select3.go index a1a2ef50b..47941063c 100644 --- a/test/chan/select3.go +++ b/test/chan/select3.go @@ -97,13 +97,9 @@ func main() { } }) - // sending (a small number of times) to a closed channel is not specified - // but the current implementation doesn't block: test that different - // implementations behave the same - testBlock(never, func() { - for i := 0; i < 10; i++ { - closedch <- 7 - } + // sending to a closed channel panics. + testPanic(always, func() { + closedch <- 7 }) // receiving from a non-ready channel always blocks @@ -189,15 +185,24 @@ func main() { } }) - // selects with closed channels don't block + // selects with closed channels behave like ordinary operations testBlock(never, func() { select { case <-closedch: } }) - testBlock(never, func() { + testPanic(always, func() { select { case closedch <- 7: } }) + + // select should not get confused if it sees itself + testBlock(always, func() { + c := make(chan int) + select { + case c <- 1: + case <-c: + } + }) } diff --git a/test/chan/select5.go b/test/chan/select5.go new file mode 100644 index 000000000..0678b8dab --- /dev/null +++ b/test/chan/select5.go @@ -0,0 +1,482 @@ +// $G $D/$F.go && $L $F.$A && ./$A.out >tmp.go && +// $G tmp.go && $L tmp.$A && ./$A.out || echo BUG: select5 +// rm -f tmp.go + +// Copyright 2011 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Generate test of channel operations and simple selects. +// Only doing one real send or receive at a time, but phrased +// in various ways that the compiler may or may not rewrite +// into simpler expressions. + +package main + +import ( + "bufio" + "fmt" + "io" + "os" + "template" +) + +func main() { + out := bufio.NewWriter(os.Stdout) + fmt.Fprintln(out, header) + a := new(arg) + + // Generate each kind of test as a separate function to avoid + // hitting the 6g optimizer with one enormous function. + // If we name all the functions init we don't have to + // maintain a list of which ones to run. + do := func(t *template.Template) { + fmt.Fprintln(out, `func init() {`) + for ; next(); a.reset() { + run(t, a, out) + } + fmt.Fprintln(out, `}`) + } + + do(recv) + do(send) + do(recvOrder) + do(sendOrder) + do(nonblock) + + fmt.Fprintln(out, "//", a.nreset, "cases") + out.Flush() +} + +func run(t *template.Template, a interface{}, out io.Writer) { + if err := t.Execute(a, out); err != nil { + panic(err) + } +} + +type arg struct{ + def bool + nreset int +} + +func (a *arg) Maybe() bool { + return maybe() +} + +func (a *arg) MaybeDefault() bool { + if a.def { + return false + } + a.def = maybe() + return a.def +} + +func (a *arg) MustDefault() bool { + return !a.def +} + +func (a *arg) reset() { + a.def = false + a.nreset++ +} + +const header = `// GENERATED BY select5.go; DO NOT EDIT + +package main + +// channel is buffered so test is single-goroutine. +// we are not interested in the concurrency aspects +// of select, just testing that the right calls happen. +var c = make(chan int, 1) +var nilch chan int +var n = 1 +var x int +var i interface{} +var dummy = make(chan int) +var m = make(map[int]int) +var order = 0 + +func f(p *int) *int { + return p +} + +// check order of operations by ensuring that +// successive calls to checkorder have increasing o values. +func checkorder(o int) { + if o <= order { + println("invalid order", o, "after", order) + panic("order") + } + order = o +} + +func fc(c chan int, o int) chan int { + checkorder(o) + return c +} + +func fp(p *int, o int) *int { + checkorder(o) + return p +} + +func fn(n, o int) int { + checkorder(o) + return n +} + +func die(x int) { + println("have", x, "want", n) + panic("chan") +} + +func main() { + // everything happens in init funcs +} +` + +func parse(s string) *template.Template { + t := template.New(nil) + t.SetDelims("〈", "〉") + if err := t.Parse(s); err != nil { + panic(s) + } + return t +} + +var recv = parse(` + 〈# Send n, receive it one way or another into x, check that they match.〉 + c <- n + 〈.section Maybe〉 + x = <-c + 〈.or〉 + select { + 〈# Blocking or non-blocking, before the receive.〉 + 〈# The compiler implements two-case select where one is default with custom code,〉 + 〈# so test the default branch both before and after the send.〉 + 〈.section MaybeDefault〉 + default: + panic("nonblock") + 〈.end〉 + 〈# Receive from c. Different cases are direct, indirect, :=, interface, and map assignment.〉 + 〈.section Maybe〉 + case x = <-c: + 〈.or〉〈.section Maybe〉 + case *f(&x) = <-c: + 〈.or〉〈.section Maybe〉 + case y := <-c: + x = y + 〈.or〉〈.section Maybe〉 + case i = <-c: + x = i.(int) + 〈.or〉 + case m[13] = <-c: + x = m[13] + 〈.end〉〈.end〉〈.end〉〈.end〉 + 〈# Blocking or non-blocking again, after the receive.〉 + 〈.section MaybeDefault〉 + default: + panic("nonblock") + 〈.end〉 + 〈# Dummy send, receive to keep compiler from optimizing select.〉 + 〈.section Maybe〉 + case dummy <- 1: + panic("dummy send") + 〈.end〉 + 〈.section Maybe〉 + case <-dummy: + panic("dummy receive") + 〈.end〉 + 〈# Nil channel send, receive to keep compiler from optimizing select.〉 + 〈.section Maybe〉 + case nilch <- 1: + panic("nilch send") + 〈.end〉 + 〈.section Maybe〉 + case <-nilch: + panic("nilch recv") + 〈.end〉 + } + 〈.end〉 + if x != n { + die(x) + } + n++ +`) + +var recvOrder = parse(` + 〈# Send n, receive it one way or another into x, check that they match.〉 + 〈# Check order of operations along the way by calling functions that check〉 + 〈# that the argument sequence is strictly increasing.〉 + order = 0 + c <- n + 〈.section Maybe〉 + 〈# Outside of select, left-to-right rule applies.〉 + 〈# (Inside select, assignment waits until case is chosen,〉 + 〈# so right hand side happens before anything on left hand side.〉 + *fp(&x, 1) = <-fc(c, 2) + 〈.or〉〈.section Maybe〉 + m[fn(13, 1)] = <-fc(c, 2) + x = m[13] + 〈.or〉 + select { + 〈# Blocking or non-blocking, before the receive.〉 + 〈# The compiler implements two-case select where one is default with custom code,〉 + 〈# so test the default branch both before and after the send.〉 + 〈.section MaybeDefault〉 + default: + panic("nonblock") + 〈.end〉 + 〈# Receive from c. Different cases are direct, indirect, :=, interface, and map assignment.〉 + 〈.section Maybe〉 + case *fp(&x, 100) = <-fc(c, 1): + 〈.or〉〈.section Maybe〉 + case y := <-fc(c, 1): + x = y + 〈.or〉〈.section Maybe〉 + case i = <-fc(c, 1): + x = i.(int) + 〈.or〉 + case m[fn(13, 100)] = <-fc(c, 1): + x = m[13] + 〈.end〉〈.end〉〈.end〉 + 〈# Blocking or non-blocking again, after the receive.〉 + 〈.section MaybeDefault〉 + default: + panic("nonblock") + 〈.end〉 + 〈# Dummy send, receive to keep compiler from optimizing select.〉 + 〈.section Maybe〉 + case fc(dummy, 2) <- fn(1, 3): + panic("dummy send") + 〈.end〉 + 〈.section Maybe〉 + case <-fc(dummy, 4): + panic("dummy receive") + 〈.end〉 + 〈# Nil channel send, receive to keep compiler from optimizing select.〉 + 〈.section Maybe〉 + case fc(nilch, 5) <- fn(1, 6): + panic("nilch send") + 〈.end〉 + 〈.section Maybe〉 + case <-fc(nilch, 7): + panic("nilch recv") + 〈.end〉 + } + 〈.end〉〈.end〉 + if x != n { + die(x) + } + n++ +`) + +var send = parse(` + 〈# Send n one way or another, receive it into x, check that they match.〉 + 〈.section Maybe〉 + c <- n + 〈.or〉 + select { + 〈# Blocking or non-blocking, before the receive (same reason as in recv).〉 + 〈.section MaybeDefault〉 + default: + panic("nonblock") + 〈.end〉 + 〈# Send c <- n. No real special cases here, because no values come back〉 + 〈# from the send operation.〉 + case c <- n: + 〈# Blocking or non-blocking.〉 + 〈.section MaybeDefault〉 + default: + panic("nonblock") + 〈.end〉 + 〈# Dummy send, receive to keep compiler from optimizing select.〉 + 〈.section Maybe〉 + case dummy <- 1: + panic("dummy send") + 〈.end〉 + 〈.section Maybe〉 + case <-dummy: + panic("dummy receive") + 〈.end〉 + 〈# Nil channel send, receive to keep compiler from optimizing select.〉 + 〈.section Maybe〉 + case nilch <- 1: + panic("nilch send") + 〈.end〉 + 〈.section Maybe〉 + case <-nilch: + panic("nilch recv") + 〈.end〉 + } + 〈.end〉 + x = <-c + if x != n { + die(x) + } + n++ +`) + +var sendOrder = parse(` + 〈# Send n one way or another, receive it into x, check that they match.〉 + 〈# Check order of operations along the way by calling functions that check〉 + 〈# that the argument sequence is strictly increasing.〉 + order = 0 + 〈.section Maybe〉 + fc(c, 1) <- fn(n, 2) + 〈.or〉 + select { + 〈# Blocking or non-blocking, before the receive (same reason as in recv).〉 + 〈.section MaybeDefault〉 + default: + panic("nonblock") + 〈.end〉 + 〈# Send c <- n. No real special cases here, because no values come back〉 + 〈# from the send operation.〉 + case fc(c, 1) <- fn(n, 2): + 〈# Blocking or non-blocking.〉 + 〈.section MaybeDefault〉 + default: + panic("nonblock") + 〈.end〉 + 〈# Dummy send, receive to keep compiler from optimizing select.〉 + 〈.section Maybe〉 + case fc(dummy, 3) <- fn(1, 4): + panic("dummy send") + 〈.end〉 + 〈.section Maybe〉 + case <-fc(dummy, 5): + panic("dummy receive") + 〈.end〉 + 〈# Nil channel send, receive to keep compiler from optimizing select.〉 + 〈.section Maybe〉 + case fc(nilch, 6) <- fn(1, 7): + panic("nilch send") + 〈.end〉 + 〈.section Maybe〉 + case <-fc(nilch, 8): + panic("nilch recv") + 〈.end〉 + } + 〈.end〉 + x = <-c + if x != n { + die(x) + } + n++ +`) + +var nonblock = parse(` + x = n + 〈# Test various combinations of non-blocking operations.〉 + 〈# Receive assignments must not edit or even attempt to compute the address of the lhs.〉 + select { + 〈.section MaybeDefault〉 + default: + 〈.end〉 + 〈.section Maybe〉 + case dummy <- 1: + panic("dummy <- 1") + 〈.end〉 + 〈.section Maybe〉 + case nilch <- 1: + panic("nilch <- 1") + 〈.end〉 + 〈.section Maybe〉 + case <-dummy: + panic("<-dummy") + 〈.end〉 + 〈.section Maybe〉 + case x = <-dummy: + panic("<-dummy x") + 〈.end〉 + 〈.section Maybe〉 + case **(**int)(nil) = <-dummy: + panic("<-dummy (and didn't crash saving result!)") + 〈.end〉 + 〈.section Maybe〉 + case <-nilch: + panic("<-nilch") + 〈.end〉 + 〈.section Maybe〉 + case x = <-nilch: + panic("<-nilch x") + 〈.end〉 + 〈.section Maybe〉 + case **(**int)(nil) = <-nilch: + panic("<-nilch (and didn't crash saving result!)") + 〈.end〉 + 〈.section MustDefault〉 + default: + 〈.end〉 + } + if x != n { + die(x) + } + n++ +`) + +// Code for enumerating all possible paths through +// some logic. The logic should call choose(n) when +// it wants to choose between n possibilities. +// On successive runs through the logic, choose(n) +// will return 0, 1, ..., n-1. The helper maybe() is +// similar but returns true and then false. +// +// Given a function gen that generates an output +// using choose and maybe, code can generate all +// possible outputs using +// +// for next() { +// gen() +// } + +type choice struct { + i, n int +} + +var choices []choice +var cp int = -1 + +func maybe() bool { + return choose(2) == 0 +} + +func choose(n int) int { + if cp >= len(choices) { + // never asked this before: start with 0. + choices = append(choices, choice{0, n}) + cp = len(choices) + return 0 + } + // otherwise give recorded answer + if n != choices[cp].n { + panic("inconsistent choices") + } + i := choices[cp].i + cp++ + return i +} + +func next() bool { + if cp < 0 { + // start a new round + cp = 0 + return true + } + + // increment last choice sequence + cp = len(choices)-1 + for cp >= 0 && choices[cp].i == choices[cp].n-1 { + cp-- + } + if cp < 0 { + choices = choices[:0] + return false + } + choices[cp].i++ + choices = choices[:cp+1] + cp = 0 + return true +} + diff --git a/test/chan/sendstmt.go b/test/chan/sendstmt.go new file mode 100644 index 000000000..ee6f765cf --- /dev/null +++ b/test/chan/sendstmt.go @@ -0,0 +1,37 @@ +// $G $D/$F.go && $L $F.$A && ./$A.out + +// Copyright 2011 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Test various parsing cases that are a little +// different now that send is a statement, not a expression. + +package main + +func main() { + chanchan() + sendprec() +} + +func chanchan() { + cc := make(chan chan int, 1) + c := make(chan int, 1) + cc <- c + select { + case <-cc <- 2: + default: + panic("nonblock") + } + if <-c != 2 { + panic("bad receive") + } +} + +func sendprec() { + c := make(chan bool, 1) + c <- false || true // not a syntax error: same as c <- (false || true) + if !<-c { + panic("sent false") + } +} diff --git a/test/closedchan.go b/test/closedchan.go index c7c759be3..46d9d0f5d 100644 --- a/test/closedchan.go +++ b/test/closedchan.go @@ -21,14 +21,21 @@ type Chan interface { Impl() string } -// direct channel operations +// direct channel operations when possible type XChan chan int + func (c XChan) Send(x int) { c <- x } func (c XChan) Nbsend(x int) bool { - return c <- x + select { + case c <- x: + return true + default: + return false + } + panic("nbsend") } func (c XChan) Recv() int { @@ -36,8 +43,13 @@ func (c XChan) Recv() int { } func (c XChan) Nbrecv() (int, bool) { - x, ok := <-c - return x, ok + select { + case x := <-c: + return x, true + default: + return 0, false + } + panic("nbrecv") } func (c XChan) Close() { @@ -54,6 +66,7 @@ func (c XChan) Impl() string { // indirect operations via select type SChan chan int + func (c SChan) Send(x int) { select { case c <- x: @@ -62,10 +75,10 @@ func (c SChan) Send(x int) { func (c SChan) Nbsend(x int) bool { select { - case c <- x: - return true default: return false + case c <- x: + return true } panic("nbsend") } @@ -80,10 +93,10 @@ func (c SChan) Recv() int { func (c SChan) Nbrecv() (int, bool) { select { - case x := <-c: - return x, true default: return 0, false + case x := <-c: + return x, true } panic("nbrecv") } @@ -100,6 +113,71 @@ func (c SChan) Impl() string { return "(select)" } +// indirect operations via larger selects +var dummy = make(chan bool) + +type SSChan chan int + +func (c SSChan) Send(x int) { + select { + case c <- x: + case <-dummy: + } +} + +func (c SSChan) Nbsend(x int) bool { + select { + default: + return false + case <-dummy: + case c <- x: + return true + } + panic("nbsend") +} + +func (c SSChan) Recv() int { + select { + case <-dummy: + case x := <-c: + return x + } + panic("recv") +} + +func (c SSChan) Nbrecv() (int, bool) { + select { + case <-dummy: + default: + return 0, false + case x := <-c: + return x, true + } + panic("nbrecv") +} + +func (c SSChan) Close() { + close(c) +} + +func (c SSChan) Closed() bool { + return closed(c) +} + +func (c SSChan) Impl() string { + return "(select)" +} + + +func shouldPanic(f func()) { + defer func() { + if recover() == nil { + panic("did not panic") + } + }() + f() +} + func test1(c Chan) { // not closed until the close signal (a zero value) has been received. if c.Closed() { @@ -128,18 +206,15 @@ func test1(c Chan) { } // send should work with ,ok too: sent a value without blocking, so ok == true. - ok := c.Nbsend(1) - if !ok { - println("test1: send on closed got not ok", c.Impl()) - } + shouldPanic(func() { c.Nbsend(1) }) - // but the value should have been discarded. + // the value should have been discarded. if x := c.Recv(); x != 0 { println("test1: recv on closed got non-zero after send on closed:", x, c.Impl()) } // similarly Send. - c.Send(2) + shouldPanic(func() { c.Send(2) }) if x := c.Recv(); x != 0 { println("test1: recv on closed got non-zero after send on closed:", x, c.Impl()) } @@ -189,9 +264,12 @@ func closedasync() chan int { func main() { test1(XChan(closedsync())) test1(SChan(closedsync())) + test1(SSChan(closedsync())) testasync1(XChan(closedasync())) testasync1(SChan(closedasync())) + testasync1(SSChan(closedasync())) testasync2(XChan(closedasync())) testasync2(SChan(closedasync())) + testasync2(SSChan(closedasync())) } diff --git a/test/cmp6.go b/test/cmp6.go index 981a85953..4c0601187 100644 --- a/test/cmp6.go +++ b/test/cmp6.go @@ -11,6 +11,10 @@ func use(bool) {} type T1 *int type T2 *int +type T3 struct {} + +var t3 T3 + func main() { // Arguments to comparison must be // assignable one to the other (or vice versa) @@ -39,4 +43,7 @@ func main() { use(p2 == p2) use(p3 == p1) use(p3 == p2) + + // Comparison of structs should have a good message + use(t3 == t3) // ERROR "struct" } diff --git a/test/cmplx.go b/test/cmplx.go index fad96c605..d5a77d684 100644 --- a/test/cmplx.go +++ b/test/cmplx.go @@ -7,26 +7,19 @@ package main var ( - f float f32 float32 f64 float64 - c complex - c64 complex64 + c64 complex64 c128 complex128 ) - + func main() { // ok - c = cmplx(f, f) - c64 = cmplx(f32, f32) - c128 = cmplx(f64, f64) + c64 = complex(f32, f32) + c128 = complex(f64, f64) - _ = complex(0) // ok - _ = cmplx(f, f32) // ERROR "cmplx" - _ = cmplx(f, f64) // ERROR "cmplx" - _ = cmplx(f32, f) // ERROR "cmplx" - _ = cmplx(f32, f64) // ERROR "cmplx" - _ = cmplx(f64, f) // ERROR "cmplx" - _ = cmplx(f64, f32) // ERROR "cmplx" + _ = complex128(0) // ok + _ = complex(f32, f64) // ERROR "complex" + _ = complex(f64, f32) // ERROR "complex" } diff --git a/test/cmplxdivide.c b/test/cmplxdivide.c index b3c6055ed..b340f04d8 100644 --- a/test/cmplxdivide.c +++ b/test/cmplxdivide.c @@ -72,7 +72,7 @@ main(void) if(iscnan(n) && d == 0) q = (NAN+NAN*I) / zero; - printf("\tTest{cmplx(%s, %s), cmplx(%s, %s), cmplx(%s, %s)},\n", + printf("\tTest{complex(%s, %s), complex(%s, %s), complex(%s, %s)},\n", fmt(creal(n)), fmt(cimag(n)), fmt(creal(d)), fmt(cimag(d)), fmt(creal(q)), fmt(cimag(q))); diff --git a/test/cmplxdivide1.go b/test/cmplxdivide1.go index 96ea704a3..6a1dee9fe 100644 --- a/test/cmplxdivide1.go +++ b/test/cmplxdivide1.go @@ -1,2407 +1,2406 @@ // # generated by cmplxdivide.c package main - var tests = []Test{ - Test{cmplx(0, 0), cmplx(0, 0), cmplx(nan, nan)}, - Test{cmplx(0, 0), cmplx(0, 1), cmplx(0, 0)}, - Test{cmplx(0, 0), cmplx(0, -1), cmplx(negzero, 0)}, - Test{cmplx(0, 0), cmplx(0, 2), cmplx(0, 0)}, - Test{cmplx(0, 0), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(0, 0), cmplx(0, inf), cmplx(0, 0)}, - Test{cmplx(0, 0), cmplx(0, -inf), cmplx(negzero, 0)}, - Test{cmplx(0, 0), cmplx(1, 0), cmplx(0, 0)}, - Test{cmplx(0, 0), cmplx(1, 1), cmplx(0, 0)}, - Test{cmplx(0, 0), cmplx(1, -1), cmplx(0, 0)}, - Test{cmplx(0, 0), cmplx(1, 2), cmplx(0, 0)}, - Test{cmplx(0, 0), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(0, 0), cmplx(1, inf), cmplx(0, 0)}, - Test{cmplx(0, 0), cmplx(1, -inf), cmplx(negzero, 0)}, - Test{cmplx(0, 0), cmplx(-1, 0), cmplx(negzero, negzero)}, - Test{cmplx(0, 0), cmplx(-1, 1), cmplx(negzero, negzero)}, - Test{cmplx(0, 0), cmplx(-1, -1), cmplx(negzero, negzero)}, - Test{cmplx(0, 0), cmplx(-1, 2), cmplx(0, negzero)}, - Test{cmplx(0, 0), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(0, 0), cmplx(-1, inf), cmplx(0, negzero)}, - Test{cmplx(0, 0), cmplx(-1, -inf), cmplx(negzero, negzero)}, - Test{cmplx(0, 0), cmplx(2, 0), cmplx(0, 0)}, - Test{cmplx(0, 0), cmplx(2, 1), cmplx(0, 0)}, - Test{cmplx(0, 0), cmplx(2, -1), cmplx(0, 0)}, - Test{cmplx(0, 0), cmplx(2, 2), cmplx(0, 0)}, - Test{cmplx(0, 0), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(0, 0), cmplx(2, inf), cmplx(0, 0)}, - Test{cmplx(0, 0), cmplx(2, -inf), cmplx(negzero, 0)}, - Test{cmplx(0, 0), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(0, 0), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(0, 0), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(0, 0), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(0, 0), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(0, 0), cmplx(nan, inf), cmplx(0, 0)}, - Test{cmplx(0, 0), cmplx(nan, -inf), cmplx(0, 0)}, - Test{cmplx(0, 0), cmplx(inf, 0), cmplx(0, 0)}, - Test{cmplx(0, 0), cmplx(inf, 1), cmplx(0, 0)}, - Test{cmplx(0, 0), cmplx(inf, -1), cmplx(0, 0)}, - Test{cmplx(0, 0), cmplx(inf, 2), cmplx(0, 0)}, - Test{cmplx(0, 0), cmplx(inf, nan), cmplx(0, 0)}, - Test{cmplx(0, 0), cmplx(inf, inf), cmplx(0, 0)}, - Test{cmplx(0, 0), cmplx(inf, -inf), cmplx(0, 0)}, - Test{cmplx(0, 0), cmplx(-inf, 0), cmplx(negzero, negzero)}, - Test{cmplx(0, 0), cmplx(-inf, 1), cmplx(negzero, negzero)}, - Test{cmplx(0, 0), cmplx(-inf, -1), cmplx(negzero, negzero)}, - Test{cmplx(0, 0), cmplx(-inf, 2), cmplx(negzero, negzero)}, - Test{cmplx(0, 0), cmplx(-inf, nan), cmplx(0, negzero)}, - Test{cmplx(0, 0), cmplx(-inf, inf), cmplx(0, negzero)}, - Test{cmplx(0, 0), cmplx(-inf, -inf), cmplx(negzero, 0)}, - Test{cmplx(0, 1), cmplx(0, 0), cmplx(nan, inf)}, - Test{cmplx(0, 1), cmplx(0, 1), cmplx(1, 0)}, - Test{cmplx(0, 1), cmplx(0, -1), cmplx(-1, 0)}, - Test{cmplx(0, 1), cmplx(0, 2), cmplx(0.5, 0)}, - Test{cmplx(0, 1), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(0, 1), cmplx(0, inf), cmplx(0, 0)}, - Test{cmplx(0, 1), cmplx(0, -inf), cmplx(negzero, 0)}, - Test{cmplx(0, 1), cmplx(1, 0), cmplx(0, 1)}, - Test{cmplx(0, 1), cmplx(1, 1), cmplx(0.5, 0.5)}, - Test{cmplx(0, 1), cmplx(1, -1), cmplx(-0.5, 0.5)}, - Test{cmplx(0, 1), cmplx(1, 2), cmplx(0.4, 0.2)}, - Test{cmplx(0, 1), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(0, 1), cmplx(1, inf), cmplx(0, 0)}, - Test{cmplx(0, 1), cmplx(1, -inf), cmplx(negzero, 0)}, - Test{cmplx(0, 1), cmplx(-1, 0), cmplx(negzero, -1)}, - Test{cmplx(0, 1), cmplx(-1, 1), cmplx(0.5, -0.5)}, - Test{cmplx(0, 1), cmplx(-1, -1), cmplx(-0.5, -0.5)}, - Test{cmplx(0, 1), cmplx(-1, 2), cmplx(0.4, -0.2)}, - Test{cmplx(0, 1), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(0, 1), cmplx(-1, inf), cmplx(0, negzero)}, - Test{cmplx(0, 1), cmplx(-1, -inf), cmplx(negzero, negzero)}, - Test{cmplx(0, 1), cmplx(2, 0), cmplx(0, 0.5)}, - Test{cmplx(0, 1), cmplx(2, 1), cmplx(0.2, 0.4)}, - Test{cmplx(0, 1), cmplx(2, -1), cmplx(-0.2, 0.4)}, - Test{cmplx(0, 1), cmplx(2, 2), cmplx(0.25, 0.25)}, - Test{cmplx(0, 1), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(0, 1), cmplx(2, inf), cmplx(0, 0)}, - Test{cmplx(0, 1), cmplx(2, -inf), cmplx(negzero, 0)}, - Test{cmplx(0, 1), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(0, 1), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(0, 1), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(0, 1), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(0, 1), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(0, 1), cmplx(nan, inf), cmplx(0, 0)}, - Test{cmplx(0, 1), cmplx(nan, -inf), cmplx(negzero, 0)}, - Test{cmplx(0, 1), cmplx(inf, 0), cmplx(0, 0)}, - Test{cmplx(0, 1), cmplx(inf, 1), cmplx(0, 0)}, - Test{cmplx(0, 1), cmplx(inf, -1), cmplx(0, 0)}, - Test{cmplx(0, 1), cmplx(inf, 2), cmplx(0, 0)}, - Test{cmplx(0, 1), cmplx(inf, nan), cmplx(0, 0)}, - Test{cmplx(0, 1), cmplx(inf, inf), cmplx(0, 0)}, - Test{cmplx(0, 1), cmplx(inf, -inf), cmplx(negzero, 0)}, - Test{cmplx(0, 1), cmplx(-inf, 0), cmplx(negzero, negzero)}, - Test{cmplx(0, 1), cmplx(-inf, 1), cmplx(negzero, negzero)}, - Test{cmplx(0, 1), cmplx(-inf, -1), cmplx(negzero, negzero)}, - Test{cmplx(0, 1), cmplx(-inf, 2), cmplx(negzero, negzero)}, - Test{cmplx(0, 1), cmplx(-inf, nan), cmplx(0, negzero)}, - Test{cmplx(0, 1), cmplx(-inf, inf), cmplx(0, negzero)}, - Test{cmplx(0, 1), cmplx(-inf, -inf), cmplx(negzero, negzero)}, - Test{cmplx(0, -1), cmplx(0, 0), cmplx(nan, -inf)}, - Test{cmplx(0, -1), cmplx(0, 1), cmplx(-1, negzero)}, - Test{cmplx(0, -1), cmplx(0, -1), cmplx(1, negzero)}, - Test{cmplx(0, -1), cmplx(0, 2), cmplx(-0.5, negzero)}, - Test{cmplx(0, -1), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(0, -1), cmplx(0, inf), cmplx(negzero, negzero)}, - Test{cmplx(0, -1), cmplx(0, -inf), cmplx(0, negzero)}, - Test{cmplx(0, -1), cmplx(1, 0), cmplx(0, -1)}, - Test{cmplx(0, -1), cmplx(1, 1), cmplx(-0.5, -0.5)}, - Test{cmplx(0, -1), cmplx(1, -1), cmplx(0.5, -0.5)}, - Test{cmplx(0, -1), cmplx(1, 2), cmplx(-0.4, -0.2)}, - Test{cmplx(0, -1), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(0, -1), cmplx(1, inf), cmplx(negzero, negzero)}, - Test{cmplx(0, -1), cmplx(1, -inf), cmplx(0, negzero)}, - Test{cmplx(0, -1), cmplx(-1, 0), cmplx(negzero, 1)}, - Test{cmplx(0, -1), cmplx(-1, 1), cmplx(-0.5, 0.5)}, - Test{cmplx(0, -1), cmplx(-1, -1), cmplx(0.5, 0.5)}, - Test{cmplx(0, -1), cmplx(-1, 2), cmplx(-0.4, 0.2)}, - Test{cmplx(0, -1), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(0, -1), cmplx(-1, inf), cmplx(negzero, 0)}, - Test{cmplx(0, -1), cmplx(-1, -inf), cmplx(0, 0)}, - Test{cmplx(0, -1), cmplx(2, 0), cmplx(0, -0.5)}, - Test{cmplx(0, -1), cmplx(2, 1), cmplx(-0.2, -0.4)}, - Test{cmplx(0, -1), cmplx(2, -1), cmplx(0.2, -0.4)}, - Test{cmplx(0, -1), cmplx(2, 2), cmplx(-0.25, -0.25)}, - Test{cmplx(0, -1), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(0, -1), cmplx(2, inf), cmplx(negzero, negzero)}, - Test{cmplx(0, -1), cmplx(2, -inf), cmplx(0, negzero)}, - Test{cmplx(0, -1), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(0, -1), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(0, -1), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(0, -1), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(0, -1), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(0, -1), cmplx(nan, inf), cmplx(negzero, negzero)}, - Test{cmplx(0, -1), cmplx(nan, -inf), cmplx(0, 0)}, - Test{cmplx(0, -1), cmplx(inf, 0), cmplx(0, negzero)}, - Test{cmplx(0, -1), cmplx(inf, 1), cmplx(0, negzero)}, - Test{cmplx(0, -1), cmplx(inf, -1), cmplx(0, negzero)}, - Test{cmplx(0, -1), cmplx(inf, 2), cmplx(0, negzero)}, - Test{cmplx(0, -1), cmplx(inf, nan), cmplx(0, negzero)}, - Test{cmplx(0, -1), cmplx(inf, inf), cmplx(negzero, negzero)}, - Test{cmplx(0, -1), cmplx(inf, -inf), cmplx(0, negzero)}, - Test{cmplx(0, -1), cmplx(-inf, 0), cmplx(negzero, 0)}, - Test{cmplx(0, -1), cmplx(-inf, 1), cmplx(negzero, 0)}, - Test{cmplx(0, -1), cmplx(-inf, -1), cmplx(negzero, 0)}, - Test{cmplx(0, -1), cmplx(-inf, 2), cmplx(negzero, 0)}, - Test{cmplx(0, -1), cmplx(-inf, nan), cmplx(negzero, 0)}, - Test{cmplx(0, -1), cmplx(-inf, inf), cmplx(negzero, 0)}, - Test{cmplx(0, -1), cmplx(-inf, -inf), cmplx(0, 0)}, - Test{cmplx(0, 2), cmplx(0, 0), cmplx(nan, inf)}, - Test{cmplx(0, 2), cmplx(0, 1), cmplx(2, 0)}, - Test{cmplx(0, 2), cmplx(0, -1), cmplx(-2, 0)}, - Test{cmplx(0, 2), cmplx(0, 2), cmplx(1, 0)}, - Test{cmplx(0, 2), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(0, 2), cmplx(0, inf), cmplx(0, 0)}, - Test{cmplx(0, 2), cmplx(0, -inf), cmplx(negzero, 0)}, - Test{cmplx(0, 2), cmplx(1, 0), cmplx(0, 2)}, - Test{cmplx(0, 2), cmplx(1, 1), cmplx(1, 1)}, - Test{cmplx(0, 2), cmplx(1, -1), cmplx(-1, 1)}, - Test{cmplx(0, 2), cmplx(1, 2), cmplx(0.8, 0.4)}, - Test{cmplx(0, 2), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(0, 2), cmplx(1, inf), cmplx(0, 0)}, - Test{cmplx(0, 2), cmplx(1, -inf), cmplx(negzero, 0)}, - Test{cmplx(0, 2), cmplx(-1, 0), cmplx(negzero, -2)}, - Test{cmplx(0, 2), cmplx(-1, 1), cmplx(1, -1)}, - Test{cmplx(0, 2), cmplx(-1, -1), cmplx(-1, -1)}, - Test{cmplx(0, 2), cmplx(-1, 2), cmplx(0.8, -0.4)}, - Test{cmplx(0, 2), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(0, 2), cmplx(-1, inf), cmplx(0, negzero)}, - Test{cmplx(0, 2), cmplx(-1, -inf), cmplx(negzero, negzero)}, - Test{cmplx(0, 2), cmplx(2, 0), cmplx(0, 1)}, - Test{cmplx(0, 2), cmplx(2, 1), cmplx(0.4, 0.8)}, - Test{cmplx(0, 2), cmplx(2, -1), cmplx(-0.4, 0.8)}, - Test{cmplx(0, 2), cmplx(2, 2), cmplx(0.5, 0.5)}, - Test{cmplx(0, 2), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(0, 2), cmplx(2, inf), cmplx(0, 0)}, - Test{cmplx(0, 2), cmplx(2, -inf), cmplx(negzero, 0)}, - Test{cmplx(0, 2), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(0, 2), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(0, 2), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(0, 2), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(0, 2), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(0, 2), cmplx(nan, inf), cmplx(0, 0)}, - Test{cmplx(0, 2), cmplx(nan, -inf), cmplx(negzero, 0)}, - Test{cmplx(0, 2), cmplx(inf, 0), cmplx(0, 0)}, - Test{cmplx(0, 2), cmplx(inf, 1), cmplx(0, 0)}, - Test{cmplx(0, 2), cmplx(inf, -1), cmplx(0, 0)}, - Test{cmplx(0, 2), cmplx(inf, 2), cmplx(0, 0)}, - Test{cmplx(0, 2), cmplx(inf, nan), cmplx(0, 0)}, - Test{cmplx(0, 2), cmplx(inf, inf), cmplx(0, 0)}, - Test{cmplx(0, 2), cmplx(inf, -inf), cmplx(negzero, 0)}, - Test{cmplx(0, 2), cmplx(-inf, 0), cmplx(negzero, negzero)}, - Test{cmplx(0, 2), cmplx(-inf, 1), cmplx(negzero, negzero)}, - Test{cmplx(0, 2), cmplx(-inf, -1), cmplx(negzero, negzero)}, - Test{cmplx(0, 2), cmplx(-inf, 2), cmplx(negzero, negzero)}, - Test{cmplx(0, 2), cmplx(-inf, nan), cmplx(0, negzero)}, - Test{cmplx(0, 2), cmplx(-inf, inf), cmplx(0, negzero)}, - Test{cmplx(0, 2), cmplx(-inf, -inf), cmplx(negzero, negzero)}, - Test{cmplx(0, nan), cmplx(0, 0), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(0, 1), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(0, -1), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(0, 2), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(1, 0), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(1, 1), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(1, -1), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(1, 2), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(-1, 0), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(-1, 1), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(-1, -1), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(-1, 2), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(2, 0), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(2, 1), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(2, -1), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(2, 2), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(0, 0), cmplx(nan, inf)}, - Test{cmplx(0, inf), cmplx(0, 1), cmplx(inf, nan)}, - Test{cmplx(0, inf), cmplx(0, -1), cmplx(-inf, nan)}, - Test{cmplx(0, inf), cmplx(0, 2), cmplx(inf, nan)}, - Test{cmplx(0, inf), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(1, 0), cmplx(nan, inf)}, - Test{cmplx(0, inf), cmplx(1, 1), cmplx(inf, inf)}, - Test{cmplx(0, inf), cmplx(1, -1), cmplx(-inf, inf)}, - Test{cmplx(0, inf), cmplx(1, 2), cmplx(inf, inf)}, - Test{cmplx(0, inf), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(-1, 0), cmplx(nan, -inf)}, - Test{cmplx(0, inf), cmplx(-1, 1), cmplx(inf, -inf)}, - Test{cmplx(0, inf), cmplx(-1, -1), cmplx(-inf, -inf)}, - Test{cmplx(0, inf), cmplx(-1, 2), cmplx(inf, -inf)}, - Test{cmplx(0, inf), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(2, 0), cmplx(nan, inf)}, - Test{cmplx(0, inf), cmplx(2, 1), cmplx(inf, inf)}, - Test{cmplx(0, inf), cmplx(2, -1), cmplx(-inf, inf)}, - Test{cmplx(0, inf), cmplx(2, 2), cmplx(inf, inf)}, - Test{cmplx(0, inf), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(0, 0), cmplx(nan, -inf)}, - Test{cmplx(0, -inf), cmplx(0, 1), cmplx(-inf, nan)}, - Test{cmplx(0, -inf), cmplx(0, -1), cmplx(inf, nan)}, - Test{cmplx(0, -inf), cmplx(0, 2), cmplx(-inf, nan)}, - Test{cmplx(0, -inf), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(1, 0), cmplx(nan, -inf)}, - Test{cmplx(0, -inf), cmplx(1, 1), cmplx(-inf, -inf)}, - Test{cmplx(0, -inf), cmplx(1, -1), cmplx(inf, -inf)}, - Test{cmplx(0, -inf), cmplx(1, 2), cmplx(-inf, -inf)}, - Test{cmplx(0, -inf), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(-1, 0), cmplx(nan, inf)}, - Test{cmplx(0, -inf), cmplx(-1, 1), cmplx(-inf, inf)}, - Test{cmplx(0, -inf), cmplx(-1, -1), cmplx(inf, inf)}, - Test{cmplx(0, -inf), cmplx(-1, 2), cmplx(-inf, inf)}, - Test{cmplx(0, -inf), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(2, 0), cmplx(nan, -inf)}, - Test{cmplx(0, -inf), cmplx(2, 1), cmplx(-inf, -inf)}, - Test{cmplx(0, -inf), cmplx(2, -1), cmplx(inf, -inf)}, - Test{cmplx(0, -inf), cmplx(2, 2), cmplx(-inf, -inf)}, - Test{cmplx(0, -inf), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(1, 0), cmplx(0, 0), cmplx(inf, nan)}, - Test{cmplx(1, 0), cmplx(0, 1), cmplx(0, -1)}, - Test{cmplx(1, 0), cmplx(0, -1), cmplx(negzero, 1)}, - Test{cmplx(1, 0), cmplx(0, 2), cmplx(0, -0.5)}, - Test{cmplx(1, 0), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(1, 0), cmplx(0, inf), cmplx(0, negzero)}, - Test{cmplx(1, 0), cmplx(0, -inf), cmplx(negzero, 0)}, - Test{cmplx(1, 0), cmplx(1, 0), cmplx(1, 0)}, - Test{cmplx(1, 0), cmplx(1, 1), cmplx(0.5, -0.5)}, - Test{cmplx(1, 0), cmplx(1, -1), cmplx(0.5, 0.5)}, - Test{cmplx(1, 0), cmplx(1, 2), cmplx(0.2, -0.4)}, - Test{cmplx(1, 0), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(1, 0), cmplx(1, inf), cmplx(0, negzero)}, - Test{cmplx(1, 0), cmplx(1, -inf), cmplx(negzero, 0)}, - Test{cmplx(1, 0), cmplx(-1, 0), cmplx(-1, negzero)}, - Test{cmplx(1, 0), cmplx(-1, 1), cmplx(-0.5, -0.5)}, - Test{cmplx(1, 0), cmplx(-1, -1), cmplx(-0.5, 0.5)}, - Test{cmplx(1, 0), cmplx(-1, 2), cmplx(-0.2, -0.4)}, - Test{cmplx(1, 0), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(1, 0), cmplx(-1, inf), cmplx(0, negzero)}, - Test{cmplx(1, 0), cmplx(-1, -inf), cmplx(negzero, 0)}, - Test{cmplx(1, 0), cmplx(2, 0), cmplx(0.5, 0)}, - Test{cmplx(1, 0), cmplx(2, 1), cmplx(0.4, -0.2)}, - Test{cmplx(1, 0), cmplx(2, -1), cmplx(0.4, 0.2)}, - Test{cmplx(1, 0), cmplx(2, 2), cmplx(0.25, -0.25)}, - Test{cmplx(1, 0), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(1, 0), cmplx(2, inf), cmplx(0, negzero)}, - Test{cmplx(1, 0), cmplx(2, -inf), cmplx(negzero, 0)}, - Test{cmplx(1, 0), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(1, 0), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(1, 0), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(1, 0), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(1, 0), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(1, 0), cmplx(nan, inf), cmplx(0, negzero)}, - Test{cmplx(1, 0), cmplx(nan, -inf), cmplx(0, 0)}, - Test{cmplx(1, 0), cmplx(inf, 0), cmplx(0, 0)}, - Test{cmplx(1, 0), cmplx(inf, 1), cmplx(0, 0)}, - Test{cmplx(1, 0), cmplx(inf, -1), cmplx(0, 0)}, - Test{cmplx(1, 0), cmplx(inf, 2), cmplx(0, 0)}, - Test{cmplx(1, 0), cmplx(inf, nan), cmplx(0, 0)}, - Test{cmplx(1, 0), cmplx(inf, inf), cmplx(0, negzero)}, - Test{cmplx(1, 0), cmplx(inf, -inf), cmplx(0, 0)}, - Test{cmplx(1, 0), cmplx(-inf, 0), cmplx(negzero, negzero)}, - Test{cmplx(1, 0), cmplx(-inf, 1), cmplx(negzero, negzero)}, - Test{cmplx(1, 0), cmplx(-inf, -1), cmplx(negzero, negzero)}, - Test{cmplx(1, 0), cmplx(-inf, 2), cmplx(negzero, negzero)}, - Test{cmplx(1, 0), cmplx(-inf, nan), cmplx(negzero, negzero)}, - Test{cmplx(1, 0), cmplx(-inf, inf), cmplx(negzero, negzero)}, - Test{cmplx(1, 0), cmplx(-inf, -inf), cmplx(negzero, 0)}, - Test{cmplx(1, 1), cmplx(0, 0), cmplx(inf, inf)}, - Test{cmplx(1, 1), cmplx(0, 1), cmplx(1, -1)}, - Test{cmplx(1, 1), cmplx(0, -1), cmplx(-1, 1)}, - Test{cmplx(1, 1), cmplx(0, 2), cmplx(0.5, -0.5)}, - Test{cmplx(1, 1), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(1, 1), cmplx(0, inf), cmplx(0, negzero)}, - Test{cmplx(1, 1), cmplx(0, -inf), cmplx(negzero, 0)}, - Test{cmplx(1, 1), cmplx(1, 0), cmplx(1, 1)}, - Test{cmplx(1, 1), cmplx(1, 1), cmplx(1, 0)}, - Test{cmplx(1, 1), cmplx(1, -1), cmplx(0, 1)}, - Test{cmplx(1, 1), cmplx(1, 2), cmplx(0.6, -0.2)}, - Test{cmplx(1, 1), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(1, 1), cmplx(1, inf), cmplx(0, negzero)}, - Test{cmplx(1, 1), cmplx(1, -inf), cmplx(negzero, 0)}, - Test{cmplx(1, 1), cmplx(-1, 0), cmplx(-1, -1)}, - Test{cmplx(1, 1), cmplx(-1, 1), cmplx(negzero, -1)}, - Test{cmplx(1, 1), cmplx(-1, -1), cmplx(-1, negzero)}, - Test{cmplx(1, 1), cmplx(-1, 2), cmplx(0.2, -0.6)}, - Test{cmplx(1, 1), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(1, 1), cmplx(-1, inf), cmplx(0, negzero)}, - Test{cmplx(1, 1), cmplx(-1, -inf), cmplx(negzero, 0)}, - Test{cmplx(1, 1), cmplx(2, 0), cmplx(0.5, 0.5)}, - Test{cmplx(1, 1), cmplx(2, 1), cmplx(0.6, 0.2)}, - Test{cmplx(1, 1), cmplx(2, -1), cmplx(0.2, 0.6)}, - Test{cmplx(1, 1), cmplx(2, 2), cmplx(0.5, 0)}, - Test{cmplx(1, 1), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(1, 1), cmplx(2, inf), cmplx(0, negzero)}, - Test{cmplx(1, 1), cmplx(2, -inf), cmplx(negzero, 0)}, - Test{cmplx(1, 1), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(1, 1), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(1, 1), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(1, 1), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(1, 1), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(1, 1), cmplx(nan, inf), cmplx(0, negzero)}, - Test{cmplx(1, 1), cmplx(nan, -inf), cmplx(negzero, 0)}, - Test{cmplx(1, 1), cmplx(inf, 0), cmplx(0, 0)}, - Test{cmplx(1, 1), cmplx(inf, 1), cmplx(0, 0)}, - Test{cmplx(1, 1), cmplx(inf, -1), cmplx(0, 0)}, - Test{cmplx(1, 1), cmplx(inf, 2), cmplx(0, 0)}, - Test{cmplx(1, 1), cmplx(inf, nan), cmplx(0, 0)}, - Test{cmplx(1, 1), cmplx(inf, inf), cmplx(0, 0)}, - Test{cmplx(1, 1), cmplx(inf, -inf), cmplx(0, 0)}, - Test{cmplx(1, 1), cmplx(-inf, 0), cmplx(negzero, negzero)}, - Test{cmplx(1, 1), cmplx(-inf, 1), cmplx(negzero, negzero)}, - Test{cmplx(1, 1), cmplx(-inf, -1), cmplx(negzero, negzero)}, - Test{cmplx(1, 1), cmplx(-inf, 2), cmplx(negzero, negzero)}, - Test{cmplx(1, 1), cmplx(-inf, nan), cmplx(negzero, negzero)}, - Test{cmplx(1, 1), cmplx(-inf, inf), cmplx(0, negzero)}, - Test{cmplx(1, 1), cmplx(-inf, -inf), cmplx(negzero, 0)}, - Test{cmplx(1, -1), cmplx(0, 0), cmplx(inf, -inf)}, - Test{cmplx(1, -1), cmplx(0, 1), cmplx(-1, -1)}, - Test{cmplx(1, -1), cmplx(0, -1), cmplx(1, 1)}, - Test{cmplx(1, -1), cmplx(0, 2), cmplx(-0.5, -0.5)}, - Test{cmplx(1, -1), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(1, -1), cmplx(0, inf), cmplx(negzero, negzero)}, - Test{cmplx(1, -1), cmplx(0, -inf), cmplx(0, 0)}, - Test{cmplx(1, -1), cmplx(1, 0), cmplx(1, -1)}, - Test{cmplx(1, -1), cmplx(1, 1), cmplx(0, -1)}, - Test{cmplx(1, -1), cmplx(1, -1), cmplx(1, 0)}, - Test{cmplx(1, -1), cmplx(1, 2), cmplx(-0.2, -0.6)}, - Test{cmplx(1, -1), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(1, -1), cmplx(1, inf), cmplx(negzero, negzero)}, - Test{cmplx(1, -1), cmplx(1, -inf), cmplx(0, 0)}, - Test{cmplx(1, -1), cmplx(-1, 0), cmplx(-1, 1)}, - Test{cmplx(1, -1), cmplx(-1, 1), cmplx(-1, negzero)}, - Test{cmplx(1, -1), cmplx(-1, -1), cmplx(negzero, 1)}, - Test{cmplx(1, -1), cmplx(-1, 2), cmplx(-0.6, -0.2)}, - Test{cmplx(1, -1), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(1, -1), cmplx(-1, inf), cmplx(negzero, negzero)}, - Test{cmplx(1, -1), cmplx(-1, -inf), cmplx(0, 0)}, - Test{cmplx(1, -1), cmplx(2, 0), cmplx(0.5, -0.5)}, - Test{cmplx(1, -1), cmplx(2, 1), cmplx(0.2, -0.6)}, - Test{cmplx(1, -1), cmplx(2, -1), cmplx(0.6, -0.2)}, - Test{cmplx(1, -1), cmplx(2, 2), cmplx(0, -0.5)}, - Test{cmplx(1, -1), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(1, -1), cmplx(2, inf), cmplx(negzero, negzero)}, - Test{cmplx(1, -1), cmplx(2, -inf), cmplx(0, 0)}, - Test{cmplx(1, -1), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(1, -1), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(1, -1), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(1, -1), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(1, -1), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(1, -1), cmplx(nan, inf), cmplx(negzero, negzero)}, - Test{cmplx(1, -1), cmplx(nan, -inf), cmplx(0, 0)}, - Test{cmplx(1, -1), cmplx(inf, 0), cmplx(0, negzero)}, - Test{cmplx(1, -1), cmplx(inf, 1), cmplx(0, negzero)}, - Test{cmplx(1, -1), cmplx(inf, -1), cmplx(0, negzero)}, - Test{cmplx(1, -1), cmplx(inf, 2), cmplx(0, negzero)}, - Test{cmplx(1, -1), cmplx(inf, nan), cmplx(0, negzero)}, - Test{cmplx(1, -1), cmplx(inf, inf), cmplx(0, negzero)}, - Test{cmplx(1, -1), cmplx(inf, -inf), cmplx(0, 0)}, - Test{cmplx(1, -1), cmplx(-inf, 0), cmplx(negzero, 0)}, - Test{cmplx(1, -1), cmplx(-inf, 1), cmplx(negzero, 0)}, - Test{cmplx(1, -1), cmplx(-inf, -1), cmplx(negzero, 0)}, - Test{cmplx(1, -1), cmplx(-inf, 2), cmplx(negzero, 0)}, - Test{cmplx(1, -1), cmplx(-inf, nan), cmplx(negzero, 0)}, - Test{cmplx(1, -1), cmplx(-inf, inf), cmplx(negzero, 0)}, - Test{cmplx(1, -1), cmplx(-inf, -inf), cmplx(0, 0)}, - Test{cmplx(1, 2), cmplx(0, 0), cmplx(inf, inf)}, - Test{cmplx(1, 2), cmplx(0, 1), cmplx(2, -1)}, - Test{cmplx(1, 2), cmplx(0, -1), cmplx(-2, 1)}, - Test{cmplx(1, 2), cmplx(0, 2), cmplx(1, -0.5)}, - Test{cmplx(1, 2), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(1, 2), cmplx(0, inf), cmplx(0, negzero)}, - Test{cmplx(1, 2), cmplx(0, -inf), cmplx(negzero, 0)}, - Test{cmplx(1, 2), cmplx(1, 0), cmplx(1, 2)}, - Test{cmplx(1, 2), cmplx(1, 1), cmplx(1.5, 0.5)}, - Test{cmplx(1, 2), cmplx(1, -1), cmplx(-0.5, 1.5)}, - Test{cmplx(1, 2), cmplx(1, 2), cmplx(1, 0)}, - Test{cmplx(1, 2), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(1, 2), cmplx(1, inf), cmplx(0, negzero)}, - Test{cmplx(1, 2), cmplx(1, -inf), cmplx(negzero, 0)}, - Test{cmplx(1, 2), cmplx(-1, 0), cmplx(-1, -2)}, - Test{cmplx(1, 2), cmplx(-1, 1), cmplx(0.5, -1.5)}, - Test{cmplx(1, 2), cmplx(-1, -1), cmplx(-1.5, -0.5)}, - Test{cmplx(1, 2), cmplx(-1, 2), cmplx(0.6, -0.8)}, - Test{cmplx(1, 2), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(1, 2), cmplx(-1, inf), cmplx(0, negzero)}, - Test{cmplx(1, 2), cmplx(-1, -inf), cmplx(negzero, 0)}, - Test{cmplx(1, 2), cmplx(2, 0), cmplx(0.5, 1)}, - Test{cmplx(1, 2), cmplx(2, 1), cmplx(0.8, 0.6)}, - Test{cmplx(1, 2), cmplx(2, -1), cmplx(0, 1)}, - Test{cmplx(1, 2), cmplx(2, 2), cmplx(0.75, 0.25)}, - Test{cmplx(1, 2), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(1, 2), cmplx(2, inf), cmplx(0, negzero)}, - Test{cmplx(1, 2), cmplx(2, -inf), cmplx(negzero, 0)}, - Test{cmplx(1, 2), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(1, 2), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(1, 2), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(1, 2), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(1, 2), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(1, 2), cmplx(nan, inf), cmplx(0, negzero)}, - Test{cmplx(1, 2), cmplx(nan, -inf), cmplx(negzero, 0)}, - Test{cmplx(1, 2), cmplx(inf, 0), cmplx(0, 0)}, - Test{cmplx(1, 2), cmplx(inf, 1), cmplx(0, 0)}, - Test{cmplx(1, 2), cmplx(inf, -1), cmplx(0, 0)}, - Test{cmplx(1, 2), cmplx(inf, 2), cmplx(0, 0)}, - Test{cmplx(1, 2), cmplx(inf, nan), cmplx(0, 0)}, - Test{cmplx(1, 2), cmplx(inf, inf), cmplx(0, 0)}, - Test{cmplx(1, 2), cmplx(inf, -inf), cmplx(negzero, 0)}, - Test{cmplx(1, 2), cmplx(-inf, 0), cmplx(negzero, negzero)}, - Test{cmplx(1, 2), cmplx(-inf, 1), cmplx(negzero, negzero)}, - Test{cmplx(1, 2), cmplx(-inf, -1), cmplx(negzero, negzero)}, - Test{cmplx(1, 2), cmplx(-inf, 2), cmplx(negzero, negzero)}, - Test{cmplx(1, 2), cmplx(-inf, nan), cmplx(negzero, negzero)}, - Test{cmplx(1, 2), cmplx(-inf, inf), cmplx(0, negzero)}, - Test{cmplx(1, 2), cmplx(-inf, -inf), cmplx(negzero, negzero)}, - Test{cmplx(1, nan), cmplx(0, 0), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(0, 1), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(0, -1), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(0, 2), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(1, 0), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(1, 1), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(1, -1), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(1, 2), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(-1, 0), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(-1, 1), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(-1, -1), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(-1, 2), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(2, 0), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(2, 1), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(2, -1), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(2, 2), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(0, 0), cmplx(inf, inf)}, - Test{cmplx(1, inf), cmplx(0, 1), cmplx(inf, nan)}, - Test{cmplx(1, inf), cmplx(0, -1), cmplx(-inf, nan)}, - Test{cmplx(1, inf), cmplx(0, 2), cmplx(inf, nan)}, - Test{cmplx(1, inf), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(1, 0), cmplx(nan, inf)}, - Test{cmplx(1, inf), cmplx(1, 1), cmplx(inf, inf)}, - Test{cmplx(1, inf), cmplx(1, -1), cmplx(-inf, inf)}, - Test{cmplx(1, inf), cmplx(1, 2), cmplx(inf, inf)}, - Test{cmplx(1, inf), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(-1, 0), cmplx(nan, -inf)}, - Test{cmplx(1, inf), cmplx(-1, 1), cmplx(inf, -inf)}, - Test{cmplx(1, inf), cmplx(-1, -1), cmplx(-inf, -inf)}, - Test{cmplx(1, inf), cmplx(-1, 2), cmplx(inf, -inf)}, - Test{cmplx(1, inf), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(2, 0), cmplx(nan, inf)}, - Test{cmplx(1, inf), cmplx(2, 1), cmplx(inf, inf)}, - Test{cmplx(1, inf), cmplx(2, -1), cmplx(-inf, inf)}, - Test{cmplx(1, inf), cmplx(2, 2), cmplx(inf, inf)}, - Test{cmplx(1, inf), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(0, 0), cmplx(inf, -inf)}, - Test{cmplx(1, -inf), cmplx(0, 1), cmplx(-inf, nan)}, - Test{cmplx(1, -inf), cmplx(0, -1), cmplx(inf, nan)}, - Test{cmplx(1, -inf), cmplx(0, 2), cmplx(-inf, nan)}, - Test{cmplx(1, -inf), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(1, 0), cmplx(nan, -inf)}, - Test{cmplx(1, -inf), cmplx(1, 1), cmplx(-inf, -inf)}, - Test{cmplx(1, -inf), cmplx(1, -1), cmplx(inf, -inf)}, - Test{cmplx(1, -inf), cmplx(1, 2), cmplx(-inf, -inf)}, - Test{cmplx(1, -inf), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(-1, 0), cmplx(nan, inf)}, - Test{cmplx(1, -inf), cmplx(-1, 1), cmplx(-inf, inf)}, - Test{cmplx(1, -inf), cmplx(-1, -1), cmplx(inf, inf)}, - Test{cmplx(1, -inf), cmplx(-1, 2), cmplx(-inf, inf)}, - Test{cmplx(1, -inf), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(2, 0), cmplx(nan, -inf)}, - Test{cmplx(1, -inf), cmplx(2, 1), cmplx(-inf, -inf)}, - Test{cmplx(1, -inf), cmplx(2, -1), cmplx(inf, -inf)}, - Test{cmplx(1, -inf), cmplx(2, 2), cmplx(-inf, -inf)}, - Test{cmplx(1, -inf), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(-1, 0), cmplx(0, 0), cmplx(-inf, nan)}, - Test{cmplx(-1, 0), cmplx(0, 1), cmplx(0, 1)}, - Test{cmplx(-1, 0), cmplx(0, -1), cmplx(negzero, -1)}, - Test{cmplx(-1, 0), cmplx(0, 2), cmplx(0, 0.5)}, - Test{cmplx(-1, 0), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(-1, 0), cmplx(0, inf), cmplx(0, 0)}, - Test{cmplx(-1, 0), cmplx(0, -inf), cmplx(negzero, negzero)}, - Test{cmplx(-1, 0), cmplx(1, 0), cmplx(-1, 0)}, - Test{cmplx(-1, 0), cmplx(1, 1), cmplx(-0.5, 0.5)}, - Test{cmplx(-1, 0), cmplx(1, -1), cmplx(-0.5, -0.5)}, - Test{cmplx(-1, 0), cmplx(1, 2), cmplx(-0.2, 0.4)}, - Test{cmplx(-1, 0), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(-1, 0), cmplx(1, inf), cmplx(0, 0)}, - Test{cmplx(-1, 0), cmplx(1, -inf), cmplx(negzero, negzero)}, - Test{cmplx(-1, 0), cmplx(-1, 0), cmplx(1, negzero)}, - Test{cmplx(-1, 0), cmplx(-1, 1), cmplx(0.5, 0.5)}, - Test{cmplx(-1, 0), cmplx(-1, -1), cmplx(0.5, -0.5)}, - Test{cmplx(-1, 0), cmplx(-1, 2), cmplx(0.2, 0.4)}, - Test{cmplx(-1, 0), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(-1, 0), cmplx(-1, inf), cmplx(0, 0)}, - Test{cmplx(-1, 0), cmplx(-1, -inf), cmplx(negzero, negzero)}, - Test{cmplx(-1, 0), cmplx(2, 0), cmplx(-0.5, 0)}, - Test{cmplx(-1, 0), cmplx(2, 1), cmplx(-0.4, 0.2)}, - Test{cmplx(-1, 0), cmplx(2, -1), cmplx(-0.4, -0.2)}, - Test{cmplx(-1, 0), cmplx(2, 2), cmplx(-0.25, 0.25)}, - Test{cmplx(-1, 0), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(-1, 0), cmplx(2, inf), cmplx(0, 0)}, - Test{cmplx(-1, 0), cmplx(2, -inf), cmplx(negzero, negzero)}, - Test{cmplx(-1, 0), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(-1, 0), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(-1, 0), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(-1, 0), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(-1, 0), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(-1, 0), cmplx(nan, inf), cmplx(0, 0)}, - Test{cmplx(-1, 0), cmplx(nan, -inf), cmplx(negzero, negzero)}, - Test{cmplx(-1, 0), cmplx(inf, 0), cmplx(negzero, 0)}, - Test{cmplx(-1, 0), cmplx(inf, 1), cmplx(negzero, 0)}, - Test{cmplx(-1, 0), cmplx(inf, -1), cmplx(negzero, 0)}, - Test{cmplx(-1, 0), cmplx(inf, 2), cmplx(negzero, 0)}, - Test{cmplx(-1, 0), cmplx(inf, nan), cmplx(negzero, 0)}, - Test{cmplx(-1, 0), cmplx(inf, inf), cmplx(negzero, 0)}, - Test{cmplx(-1, 0), cmplx(inf, -inf), cmplx(negzero, negzero)}, - Test{cmplx(-1, 0), cmplx(-inf, 0), cmplx(0, negzero)}, - Test{cmplx(-1, 0), cmplx(-inf, 1), cmplx(0, negzero)}, - Test{cmplx(-1, 0), cmplx(-inf, -1), cmplx(0, negzero)}, - Test{cmplx(-1, 0), cmplx(-inf, 2), cmplx(0, negzero)}, - Test{cmplx(-1, 0), cmplx(-inf, nan), cmplx(0, 0)}, - Test{cmplx(-1, 0), cmplx(-inf, inf), cmplx(0, 0)}, - Test{cmplx(-1, 0), cmplx(-inf, -inf), cmplx(0, negzero)}, - Test{cmplx(-1, 1), cmplx(0, 0), cmplx(-inf, inf)}, - Test{cmplx(-1, 1), cmplx(0, 1), cmplx(1, 1)}, - Test{cmplx(-1, 1), cmplx(0, -1), cmplx(-1, -1)}, - Test{cmplx(-1, 1), cmplx(0, 2), cmplx(0.5, 0.5)}, - Test{cmplx(-1, 1), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(-1, 1), cmplx(0, inf), cmplx(0, 0)}, - Test{cmplx(-1, 1), cmplx(0, -inf), cmplx(negzero, negzero)}, - Test{cmplx(-1, 1), cmplx(1, 0), cmplx(-1, 1)}, - Test{cmplx(-1, 1), cmplx(1, 1), cmplx(0, 1)}, - Test{cmplx(-1, 1), cmplx(1, -1), cmplx(-1, 0)}, - Test{cmplx(-1, 1), cmplx(1, 2), cmplx(0.2, 0.6)}, - Test{cmplx(-1, 1), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(-1, 1), cmplx(1, inf), cmplx(0, 0)}, - Test{cmplx(-1, 1), cmplx(1, -inf), cmplx(negzero, negzero)}, - Test{cmplx(-1, 1), cmplx(-1, 0), cmplx(1, -1)}, - Test{cmplx(-1, 1), cmplx(-1, 1), cmplx(1, negzero)}, - Test{cmplx(-1, 1), cmplx(-1, -1), cmplx(negzero, -1)}, - Test{cmplx(-1, 1), cmplx(-1, 2), cmplx(0.6, 0.2)}, - Test{cmplx(-1, 1), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(-1, 1), cmplx(-1, inf), cmplx(0, 0)}, - Test{cmplx(-1, 1), cmplx(-1, -inf), cmplx(negzero, negzero)}, - Test{cmplx(-1, 1), cmplx(2, 0), cmplx(-0.5, 0.5)}, - Test{cmplx(-1, 1), cmplx(2, 1), cmplx(-0.2, 0.6)}, - Test{cmplx(-1, 1), cmplx(2, -1), cmplx(-0.6, 0.2)}, - Test{cmplx(-1, 1), cmplx(2, 2), cmplx(0, 0.5)}, - Test{cmplx(-1, 1), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(-1, 1), cmplx(2, inf), cmplx(0, 0)}, - Test{cmplx(-1, 1), cmplx(2, -inf), cmplx(negzero, negzero)}, - Test{cmplx(-1, 1), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(-1, 1), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(-1, 1), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(-1, 1), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(-1, 1), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(-1, 1), cmplx(nan, inf), cmplx(0, 0)}, - Test{cmplx(-1, 1), cmplx(nan, -inf), cmplx(negzero, negzero)}, - Test{cmplx(-1, 1), cmplx(inf, 0), cmplx(negzero, 0)}, - Test{cmplx(-1, 1), cmplx(inf, 1), cmplx(negzero, 0)}, - Test{cmplx(-1, 1), cmplx(inf, -1), cmplx(negzero, 0)}, - Test{cmplx(-1, 1), cmplx(inf, 2), cmplx(negzero, 0)}, - Test{cmplx(-1, 1), cmplx(inf, nan), cmplx(negzero, 0)}, - Test{cmplx(-1, 1), cmplx(inf, inf), cmplx(0, 0)}, - Test{cmplx(-1, 1), cmplx(inf, -inf), cmplx(negzero, 0)}, - Test{cmplx(-1, 1), cmplx(-inf, 0), cmplx(0, negzero)}, - Test{cmplx(-1, 1), cmplx(-inf, 1), cmplx(0, negzero)}, - Test{cmplx(-1, 1), cmplx(-inf, -1), cmplx(0, negzero)}, - Test{cmplx(-1, 1), cmplx(-inf, 2), cmplx(0, negzero)}, - Test{cmplx(-1, 1), cmplx(-inf, nan), cmplx(0, negzero)}, - Test{cmplx(-1, 1), cmplx(-inf, inf), cmplx(0, 0)}, - Test{cmplx(-1, 1), cmplx(-inf, -inf), cmplx(0, negzero)}, - Test{cmplx(-1, -1), cmplx(0, 0), cmplx(-inf, -inf)}, - Test{cmplx(-1, -1), cmplx(0, 1), cmplx(-1, 1)}, - Test{cmplx(-1, -1), cmplx(0, -1), cmplx(1, -1)}, - Test{cmplx(-1, -1), cmplx(0, 2), cmplx(-0.5, 0.5)}, - Test{cmplx(-1, -1), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(-1, -1), cmplx(0, inf), cmplx(negzero, 0)}, - Test{cmplx(-1, -1), cmplx(0, -inf), cmplx(0, negzero)}, - Test{cmplx(-1, -1), cmplx(1, 0), cmplx(-1, -1)}, - Test{cmplx(-1, -1), cmplx(1, 1), cmplx(-1, 0)}, - Test{cmplx(-1, -1), cmplx(1, -1), cmplx(0, -1)}, - Test{cmplx(-1, -1), cmplx(1, 2), cmplx(-0.6, 0.2)}, - Test{cmplx(-1, -1), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(-1, -1), cmplx(1, inf), cmplx(negzero, 0)}, - Test{cmplx(-1, -1), cmplx(1, -inf), cmplx(0, negzero)}, - Test{cmplx(-1, -1), cmplx(-1, 0), cmplx(1, 1)}, - Test{cmplx(-1, -1), cmplx(-1, 1), cmplx(negzero, 1)}, - Test{cmplx(-1, -1), cmplx(-1, -1), cmplx(1, negzero)}, - Test{cmplx(-1, -1), cmplx(-1, 2), cmplx(-0.2, 0.6)}, - Test{cmplx(-1, -1), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(-1, -1), cmplx(-1, inf), cmplx(negzero, 0)}, - Test{cmplx(-1, -1), cmplx(-1, -inf), cmplx(0, negzero)}, - Test{cmplx(-1, -1), cmplx(2, 0), cmplx(-0.5, -0.5)}, - Test{cmplx(-1, -1), cmplx(2, 1), cmplx(-0.6, -0.2)}, - Test{cmplx(-1, -1), cmplx(2, -1), cmplx(-0.2, -0.6)}, - Test{cmplx(-1, -1), cmplx(2, 2), cmplx(-0.5, 0)}, - Test{cmplx(-1, -1), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(-1, -1), cmplx(2, inf), cmplx(negzero, 0)}, - Test{cmplx(-1, -1), cmplx(2, -inf), cmplx(0, negzero)}, - Test{cmplx(-1, -1), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(-1, -1), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(-1, -1), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(-1, -1), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(-1, -1), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(-1, -1), cmplx(nan, inf), cmplx(negzero, 0)}, - Test{cmplx(-1, -1), cmplx(nan, -inf), cmplx(0, negzero)}, - Test{cmplx(-1, -1), cmplx(inf, 0), cmplx(negzero, negzero)}, - Test{cmplx(-1, -1), cmplx(inf, 1), cmplx(negzero, negzero)}, - Test{cmplx(-1, -1), cmplx(inf, -1), cmplx(negzero, negzero)}, - Test{cmplx(-1, -1), cmplx(inf, 2), cmplx(negzero, negzero)}, - Test{cmplx(-1, -1), cmplx(inf, nan), cmplx(negzero, negzero)}, - Test{cmplx(-1, -1), cmplx(inf, inf), cmplx(negzero, 0)}, - Test{cmplx(-1, -1), cmplx(inf, -inf), cmplx(0, negzero)}, - Test{cmplx(-1, -1), cmplx(-inf, 0), cmplx(0, 0)}, - Test{cmplx(-1, -1), cmplx(-inf, 1), cmplx(0, 0)}, - Test{cmplx(-1, -1), cmplx(-inf, -1), cmplx(0, 0)}, - Test{cmplx(-1, -1), cmplx(-inf, 2), cmplx(0, 0)}, - Test{cmplx(-1, -1), cmplx(-inf, nan), cmplx(0, 0)}, - Test{cmplx(-1, -1), cmplx(-inf, inf), cmplx(0, 0)}, - Test{cmplx(-1, -1), cmplx(-inf, -inf), cmplx(0, 0)}, - Test{cmplx(-1, 2), cmplx(0, 0), cmplx(-inf, inf)}, - Test{cmplx(-1, 2), cmplx(0, 1), cmplx(2, 1)}, - Test{cmplx(-1, 2), cmplx(0, -1), cmplx(-2, -1)}, - Test{cmplx(-1, 2), cmplx(0, 2), cmplx(1, 0.5)}, - Test{cmplx(-1, 2), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(-1, 2), cmplx(0, inf), cmplx(0, 0)}, - Test{cmplx(-1, 2), cmplx(0, -inf), cmplx(negzero, negzero)}, - Test{cmplx(-1, 2), cmplx(1, 0), cmplx(-1, 2)}, - Test{cmplx(-1, 2), cmplx(1, 1), cmplx(0.5, 1.5)}, - Test{cmplx(-1, 2), cmplx(1, -1), cmplx(-1.5, 0.5)}, - Test{cmplx(-1, 2), cmplx(1, 2), cmplx(0.6, 0.8)}, - Test{cmplx(-1, 2), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(-1, 2), cmplx(1, inf), cmplx(0, 0)}, - Test{cmplx(-1, 2), cmplx(1, -inf), cmplx(negzero, negzero)}, - Test{cmplx(-1, 2), cmplx(-1, 0), cmplx(1, -2)}, - Test{cmplx(-1, 2), cmplx(-1, 1), cmplx(1.5, -0.5)}, - Test{cmplx(-1, 2), cmplx(-1, -1), cmplx(-0.5, -1.5)}, - Test{cmplx(-1, 2), cmplx(-1, 2), cmplx(1, 0)}, - Test{cmplx(-1, 2), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(-1, 2), cmplx(-1, inf), cmplx(0, 0)}, - Test{cmplx(-1, 2), cmplx(-1, -inf), cmplx(negzero, negzero)}, - Test{cmplx(-1, 2), cmplx(2, 0), cmplx(-0.5, 1)}, - Test{cmplx(-1, 2), cmplx(2, 1), cmplx(0, 1)}, - Test{cmplx(-1, 2), cmplx(2, -1), cmplx(-0.8, 0.6)}, - Test{cmplx(-1, 2), cmplx(2, 2), cmplx(0.25, 0.75)}, - Test{cmplx(-1, 2), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(-1, 2), cmplx(2, inf), cmplx(0, 0)}, - Test{cmplx(-1, 2), cmplx(2, -inf), cmplx(negzero, negzero)}, - Test{cmplx(-1, 2), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(-1, 2), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(-1, 2), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(-1, 2), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(-1, 2), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(-1, 2), cmplx(nan, inf), cmplx(0, 0)}, - Test{cmplx(-1, 2), cmplx(nan, -inf), cmplx(negzero, negzero)}, - Test{cmplx(-1, 2), cmplx(inf, 0), cmplx(negzero, 0)}, - Test{cmplx(-1, 2), cmplx(inf, 1), cmplx(negzero, 0)}, - Test{cmplx(-1, 2), cmplx(inf, -1), cmplx(negzero, 0)}, - Test{cmplx(-1, 2), cmplx(inf, 2), cmplx(negzero, 0)}, - Test{cmplx(-1, 2), cmplx(inf, nan), cmplx(negzero, 0)}, - Test{cmplx(-1, 2), cmplx(inf, inf), cmplx(0, 0)}, - Test{cmplx(-1, 2), cmplx(inf, -inf), cmplx(negzero, 0)}, - Test{cmplx(-1, 2), cmplx(-inf, 0), cmplx(0, negzero)}, - Test{cmplx(-1, 2), cmplx(-inf, 1), cmplx(0, negzero)}, - Test{cmplx(-1, 2), cmplx(-inf, -1), cmplx(0, negzero)}, - Test{cmplx(-1, 2), cmplx(-inf, 2), cmplx(0, negzero)}, - Test{cmplx(-1, 2), cmplx(-inf, nan), cmplx(0, negzero)}, - Test{cmplx(-1, 2), cmplx(-inf, inf), cmplx(0, negzero)}, - Test{cmplx(-1, 2), cmplx(-inf, -inf), cmplx(negzero, negzero)}, - Test{cmplx(-1, nan), cmplx(0, 0), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(0, 1), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(0, -1), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(0, 2), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(1, 0), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(1, 1), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(1, -1), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(1, 2), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(-1, 0), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(-1, 1), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(-1, -1), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(-1, 2), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(2, 0), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(2, 1), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(2, -1), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(2, 2), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(0, 0), cmplx(-inf, inf)}, - Test{cmplx(-1, inf), cmplx(0, 1), cmplx(inf, nan)}, - Test{cmplx(-1, inf), cmplx(0, -1), cmplx(-inf, nan)}, - Test{cmplx(-1, inf), cmplx(0, 2), cmplx(inf, nan)}, - Test{cmplx(-1, inf), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(1, 0), cmplx(nan, inf)}, - Test{cmplx(-1, inf), cmplx(1, 1), cmplx(inf, inf)}, - Test{cmplx(-1, inf), cmplx(1, -1), cmplx(-inf, inf)}, - Test{cmplx(-1, inf), cmplx(1, 2), cmplx(inf, inf)}, - Test{cmplx(-1, inf), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(-1, 0), cmplx(nan, -inf)}, - Test{cmplx(-1, inf), cmplx(-1, 1), cmplx(inf, -inf)}, - Test{cmplx(-1, inf), cmplx(-1, -1), cmplx(-inf, -inf)}, - Test{cmplx(-1, inf), cmplx(-1, 2), cmplx(inf, -inf)}, - Test{cmplx(-1, inf), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(2, 0), cmplx(nan, inf)}, - Test{cmplx(-1, inf), cmplx(2, 1), cmplx(inf, inf)}, - Test{cmplx(-1, inf), cmplx(2, -1), cmplx(-inf, inf)}, - Test{cmplx(-1, inf), cmplx(2, 2), cmplx(inf, inf)}, - Test{cmplx(-1, inf), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(0, 0), cmplx(-inf, -inf)}, - Test{cmplx(-1, -inf), cmplx(0, 1), cmplx(-inf, nan)}, - Test{cmplx(-1, -inf), cmplx(0, -1), cmplx(inf, nan)}, - Test{cmplx(-1, -inf), cmplx(0, 2), cmplx(-inf, nan)}, - Test{cmplx(-1, -inf), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(1, 0), cmplx(nan, -inf)}, - Test{cmplx(-1, -inf), cmplx(1, 1), cmplx(-inf, -inf)}, - Test{cmplx(-1, -inf), cmplx(1, -1), cmplx(inf, -inf)}, - Test{cmplx(-1, -inf), cmplx(1, 2), cmplx(-inf, -inf)}, - Test{cmplx(-1, -inf), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(-1, 0), cmplx(nan, inf)}, - Test{cmplx(-1, -inf), cmplx(-1, 1), cmplx(-inf, inf)}, - Test{cmplx(-1, -inf), cmplx(-1, -1), cmplx(inf, inf)}, - Test{cmplx(-1, -inf), cmplx(-1, 2), cmplx(-inf, inf)}, - Test{cmplx(-1, -inf), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(2, 0), cmplx(nan, -inf)}, - Test{cmplx(-1, -inf), cmplx(2, 1), cmplx(-inf, -inf)}, - Test{cmplx(-1, -inf), cmplx(2, -1), cmplx(inf, -inf)}, - Test{cmplx(-1, -inf), cmplx(2, 2), cmplx(-inf, -inf)}, - Test{cmplx(-1, -inf), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(2, 0), cmplx(0, 0), cmplx(inf, nan)}, - Test{cmplx(2, 0), cmplx(0, 1), cmplx(0, -2)}, - Test{cmplx(2, 0), cmplx(0, -1), cmplx(negzero, 2)}, - Test{cmplx(2, 0), cmplx(0, 2), cmplx(0, -1)}, - Test{cmplx(2, 0), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(2, 0), cmplx(0, inf), cmplx(0, negzero)}, - Test{cmplx(2, 0), cmplx(0, -inf), cmplx(negzero, 0)}, - Test{cmplx(2, 0), cmplx(1, 0), cmplx(2, 0)}, - Test{cmplx(2, 0), cmplx(1, 1), cmplx(1, -1)}, - Test{cmplx(2, 0), cmplx(1, -1), cmplx(1, 1)}, - Test{cmplx(2, 0), cmplx(1, 2), cmplx(0.4, -0.8)}, - Test{cmplx(2, 0), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(2, 0), cmplx(1, inf), cmplx(0, negzero)}, - Test{cmplx(2, 0), cmplx(1, -inf), cmplx(negzero, 0)}, - Test{cmplx(2, 0), cmplx(-1, 0), cmplx(-2, negzero)}, - Test{cmplx(2, 0), cmplx(-1, 1), cmplx(-1, -1)}, - Test{cmplx(2, 0), cmplx(-1, -1), cmplx(-1, 1)}, - Test{cmplx(2, 0), cmplx(-1, 2), cmplx(-0.4, -0.8)}, - Test{cmplx(2, 0), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(2, 0), cmplx(-1, inf), cmplx(0, negzero)}, - Test{cmplx(2, 0), cmplx(-1, -inf), cmplx(negzero, 0)}, - Test{cmplx(2, 0), cmplx(2, 0), cmplx(1, 0)}, - Test{cmplx(2, 0), cmplx(2, 1), cmplx(0.8, -0.4)}, - Test{cmplx(2, 0), cmplx(2, -1), cmplx(0.8, 0.4)}, - Test{cmplx(2, 0), cmplx(2, 2), cmplx(0.5, -0.5)}, - Test{cmplx(2, 0), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(2, 0), cmplx(2, inf), cmplx(0, negzero)}, - Test{cmplx(2, 0), cmplx(2, -inf), cmplx(negzero, 0)}, - Test{cmplx(2, 0), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(2, 0), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(2, 0), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(2, 0), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(2, 0), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(2, 0), cmplx(nan, inf), cmplx(0, negzero)}, - Test{cmplx(2, 0), cmplx(nan, -inf), cmplx(0, 0)}, - Test{cmplx(2, 0), cmplx(inf, 0), cmplx(0, 0)}, - Test{cmplx(2, 0), cmplx(inf, 1), cmplx(0, 0)}, - Test{cmplx(2, 0), cmplx(inf, -1), cmplx(0, 0)}, - Test{cmplx(2, 0), cmplx(inf, 2), cmplx(0, 0)}, - Test{cmplx(2, 0), cmplx(inf, nan), cmplx(0, 0)}, - Test{cmplx(2, 0), cmplx(inf, inf), cmplx(0, negzero)}, - Test{cmplx(2, 0), cmplx(inf, -inf), cmplx(0, 0)}, - Test{cmplx(2, 0), cmplx(-inf, 0), cmplx(negzero, negzero)}, - Test{cmplx(2, 0), cmplx(-inf, 1), cmplx(negzero, negzero)}, - Test{cmplx(2, 0), cmplx(-inf, -1), cmplx(negzero, negzero)}, - Test{cmplx(2, 0), cmplx(-inf, 2), cmplx(negzero, negzero)}, - Test{cmplx(2, 0), cmplx(-inf, nan), cmplx(negzero, negzero)}, - Test{cmplx(2, 0), cmplx(-inf, inf), cmplx(negzero, negzero)}, - Test{cmplx(2, 0), cmplx(-inf, -inf), cmplx(negzero, 0)}, - Test{cmplx(2, 1), cmplx(0, 0), cmplx(inf, inf)}, - Test{cmplx(2, 1), cmplx(0, 1), cmplx(1, -2)}, - Test{cmplx(2, 1), cmplx(0, -1), cmplx(-1, 2)}, - Test{cmplx(2, 1), cmplx(0, 2), cmplx(0.5, -1)}, - Test{cmplx(2, 1), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(2, 1), cmplx(0, inf), cmplx(0, negzero)}, - Test{cmplx(2, 1), cmplx(0, -inf), cmplx(negzero, 0)}, - Test{cmplx(2, 1), cmplx(1, 0), cmplx(2, 1)}, - Test{cmplx(2, 1), cmplx(1, 1), cmplx(1.5, -0.5)}, - Test{cmplx(2, 1), cmplx(1, -1), cmplx(0.5, 1.5)}, - Test{cmplx(2, 1), cmplx(1, 2), cmplx(0.8, -0.6)}, - Test{cmplx(2, 1), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(2, 1), cmplx(1, inf), cmplx(0, negzero)}, - Test{cmplx(2, 1), cmplx(1, -inf), cmplx(negzero, 0)}, - Test{cmplx(2, 1), cmplx(-1, 0), cmplx(-2, -1)}, - Test{cmplx(2, 1), cmplx(-1, 1), cmplx(-0.5, -1.5)}, - Test{cmplx(2, 1), cmplx(-1, -1), cmplx(-1.5, 0.5)}, - Test{cmplx(2, 1), cmplx(-1, 2), cmplx(0, -1)}, - Test{cmplx(2, 1), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(2, 1), cmplx(-1, inf), cmplx(0, negzero)}, - Test{cmplx(2, 1), cmplx(-1, -inf), cmplx(negzero, 0)}, - Test{cmplx(2, 1), cmplx(2, 0), cmplx(1, 0.5)}, - Test{cmplx(2, 1), cmplx(2, 1), cmplx(1, 0)}, - Test{cmplx(2, 1), cmplx(2, -1), cmplx(0.6, 0.8)}, - Test{cmplx(2, 1), cmplx(2, 2), cmplx(0.75, -0.25)}, - Test{cmplx(2, 1), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(2, 1), cmplx(2, inf), cmplx(0, negzero)}, - Test{cmplx(2, 1), cmplx(2, -inf), cmplx(negzero, 0)}, - Test{cmplx(2, 1), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(2, 1), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(2, 1), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(2, 1), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(2, 1), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(2, 1), cmplx(nan, inf), cmplx(0, negzero)}, - Test{cmplx(2, 1), cmplx(nan, -inf), cmplx(negzero, 0)}, - Test{cmplx(2, 1), cmplx(inf, 0), cmplx(0, 0)}, - Test{cmplx(2, 1), cmplx(inf, 1), cmplx(0, 0)}, - Test{cmplx(2, 1), cmplx(inf, -1), cmplx(0, 0)}, - Test{cmplx(2, 1), cmplx(inf, 2), cmplx(0, 0)}, - Test{cmplx(2, 1), cmplx(inf, nan), cmplx(0, 0)}, - Test{cmplx(2, 1), cmplx(inf, inf), cmplx(0, negzero)}, - Test{cmplx(2, 1), cmplx(inf, -inf), cmplx(0, 0)}, - Test{cmplx(2, 1), cmplx(-inf, 0), cmplx(negzero, negzero)}, - Test{cmplx(2, 1), cmplx(-inf, 1), cmplx(negzero, negzero)}, - Test{cmplx(2, 1), cmplx(-inf, -1), cmplx(negzero, negzero)}, - Test{cmplx(2, 1), cmplx(-inf, 2), cmplx(negzero, negzero)}, - Test{cmplx(2, 1), cmplx(-inf, nan), cmplx(negzero, negzero)}, - Test{cmplx(2, 1), cmplx(-inf, inf), cmplx(negzero, negzero)}, - Test{cmplx(2, 1), cmplx(-inf, -inf), cmplx(negzero, 0)}, - Test{cmplx(2, -1), cmplx(0, 0), cmplx(inf, -inf)}, - Test{cmplx(2, -1), cmplx(0, 1), cmplx(-1, -2)}, - Test{cmplx(2, -1), cmplx(0, -1), cmplx(1, 2)}, - Test{cmplx(2, -1), cmplx(0, 2), cmplx(-0.5, -1)}, - Test{cmplx(2, -1), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(2, -1), cmplx(0, inf), cmplx(negzero, negzero)}, - Test{cmplx(2, -1), cmplx(0, -inf), cmplx(0, 0)}, - Test{cmplx(2, -1), cmplx(1, 0), cmplx(2, -1)}, - Test{cmplx(2, -1), cmplx(1, 1), cmplx(0.5, -1.5)}, - Test{cmplx(2, -1), cmplx(1, -1), cmplx(1.5, 0.5)}, - Test{cmplx(2, -1), cmplx(1, 2), cmplx(0, -1)}, - Test{cmplx(2, -1), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(2, -1), cmplx(1, inf), cmplx(negzero, negzero)}, - Test{cmplx(2, -1), cmplx(1, -inf), cmplx(0, 0)}, - Test{cmplx(2, -1), cmplx(-1, 0), cmplx(-2, 1)}, - Test{cmplx(2, -1), cmplx(-1, 1), cmplx(-1.5, -0.5)}, - Test{cmplx(2, -1), cmplx(-1, -1), cmplx(-0.5, 1.5)}, - Test{cmplx(2, -1), cmplx(-1, 2), cmplx(-0.8, -0.6)}, - Test{cmplx(2, -1), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(2, -1), cmplx(-1, inf), cmplx(negzero, negzero)}, - Test{cmplx(2, -1), cmplx(-1, -inf), cmplx(0, 0)}, - Test{cmplx(2, -1), cmplx(2, 0), cmplx(1, -0.5)}, - Test{cmplx(2, -1), cmplx(2, 1), cmplx(0.6, -0.8)}, - Test{cmplx(2, -1), cmplx(2, -1), cmplx(1, 0)}, - Test{cmplx(2, -1), cmplx(2, 2), cmplx(0.25, -0.75)}, - Test{cmplx(2, -1), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(2, -1), cmplx(2, inf), cmplx(negzero, negzero)}, - Test{cmplx(2, -1), cmplx(2, -inf), cmplx(0, 0)}, - Test{cmplx(2, -1), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(2, -1), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(2, -1), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(2, -1), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(2, -1), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(2, -1), cmplx(nan, inf), cmplx(negzero, negzero)}, - Test{cmplx(2, -1), cmplx(nan, -inf), cmplx(0, 0)}, - Test{cmplx(2, -1), cmplx(inf, 0), cmplx(0, negzero)}, - Test{cmplx(2, -1), cmplx(inf, 1), cmplx(0, negzero)}, - Test{cmplx(2, -1), cmplx(inf, -1), cmplx(0, negzero)}, - Test{cmplx(2, -1), cmplx(inf, 2), cmplx(0, negzero)}, - Test{cmplx(2, -1), cmplx(inf, nan), cmplx(0, negzero)}, - Test{cmplx(2, -1), cmplx(inf, inf), cmplx(0, negzero)}, - Test{cmplx(2, -1), cmplx(inf, -inf), cmplx(0, 0)}, - Test{cmplx(2, -1), cmplx(-inf, 0), cmplx(negzero, 0)}, - Test{cmplx(2, -1), cmplx(-inf, 1), cmplx(negzero, 0)}, - Test{cmplx(2, -1), cmplx(-inf, -1), cmplx(negzero, 0)}, - Test{cmplx(2, -1), cmplx(-inf, 2), cmplx(negzero, 0)}, - Test{cmplx(2, -1), cmplx(-inf, nan), cmplx(negzero, 0)}, - Test{cmplx(2, -1), cmplx(-inf, inf), cmplx(negzero, negzero)}, - Test{cmplx(2, -1), cmplx(-inf, -inf), cmplx(negzero, 0)}, - Test{cmplx(2, 2), cmplx(0, 0), cmplx(inf, inf)}, - Test{cmplx(2, 2), cmplx(0, 1), cmplx(2, -2)}, - Test{cmplx(2, 2), cmplx(0, -1), cmplx(-2, 2)}, - Test{cmplx(2, 2), cmplx(0, 2), cmplx(1, -1)}, - Test{cmplx(2, 2), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(2, 2), cmplx(0, inf), cmplx(0, negzero)}, - Test{cmplx(2, 2), cmplx(0, -inf), cmplx(negzero, 0)}, - Test{cmplx(2, 2), cmplx(1, 0), cmplx(2, 2)}, - Test{cmplx(2, 2), cmplx(1, 1), cmplx(2, 0)}, - Test{cmplx(2, 2), cmplx(1, -1), cmplx(0, 2)}, - Test{cmplx(2, 2), cmplx(1, 2), cmplx(1.2, -0.4)}, - Test{cmplx(2, 2), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(2, 2), cmplx(1, inf), cmplx(0, negzero)}, - Test{cmplx(2, 2), cmplx(1, -inf), cmplx(negzero, 0)}, - Test{cmplx(2, 2), cmplx(-1, 0), cmplx(-2, -2)}, - Test{cmplx(2, 2), cmplx(-1, 1), cmplx(negzero, -2)}, - Test{cmplx(2, 2), cmplx(-1, -1), cmplx(-2, negzero)}, - Test{cmplx(2, 2), cmplx(-1, 2), cmplx(0.4, -1.2)}, - Test{cmplx(2, 2), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(2, 2), cmplx(-1, inf), cmplx(0, negzero)}, - Test{cmplx(2, 2), cmplx(-1, -inf), cmplx(negzero, 0)}, - Test{cmplx(2, 2), cmplx(2, 0), cmplx(1, 1)}, - Test{cmplx(2, 2), cmplx(2, 1), cmplx(1.2, 0.4)}, - Test{cmplx(2, 2), cmplx(2, -1), cmplx(0.4, 1.2)}, - Test{cmplx(2, 2), cmplx(2, 2), cmplx(1, 0)}, - Test{cmplx(2, 2), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(2, 2), cmplx(2, inf), cmplx(0, negzero)}, - Test{cmplx(2, 2), cmplx(2, -inf), cmplx(negzero, 0)}, - Test{cmplx(2, 2), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(2, 2), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(2, 2), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(2, 2), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(2, 2), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(2, 2), cmplx(nan, inf), cmplx(0, negzero)}, - Test{cmplx(2, 2), cmplx(nan, -inf), cmplx(negzero, 0)}, - Test{cmplx(2, 2), cmplx(inf, 0), cmplx(0, 0)}, - Test{cmplx(2, 2), cmplx(inf, 1), cmplx(0, 0)}, - Test{cmplx(2, 2), cmplx(inf, -1), cmplx(0, 0)}, - Test{cmplx(2, 2), cmplx(inf, 2), cmplx(0, 0)}, - Test{cmplx(2, 2), cmplx(inf, nan), cmplx(0, 0)}, - Test{cmplx(2, 2), cmplx(inf, inf), cmplx(0, 0)}, - Test{cmplx(2, 2), cmplx(inf, -inf), cmplx(0, 0)}, - Test{cmplx(2, 2), cmplx(-inf, 0), cmplx(negzero, negzero)}, - Test{cmplx(2, 2), cmplx(-inf, 1), cmplx(negzero, negzero)}, - Test{cmplx(2, 2), cmplx(-inf, -1), cmplx(negzero, negzero)}, - Test{cmplx(2, 2), cmplx(-inf, 2), cmplx(negzero, negzero)}, - Test{cmplx(2, 2), cmplx(-inf, nan), cmplx(negzero, negzero)}, - Test{cmplx(2, 2), cmplx(-inf, inf), cmplx(0, negzero)}, - Test{cmplx(2, 2), cmplx(-inf, -inf), cmplx(negzero, 0)}, - Test{cmplx(2, nan), cmplx(0, 0), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(0, 1), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(0, -1), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(0, 2), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(1, 0), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(1, 1), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(1, -1), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(1, 2), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(-1, 0), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(-1, 1), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(-1, -1), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(-1, 2), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(2, 0), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(2, 1), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(2, -1), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(2, 2), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(0, 0), cmplx(inf, inf)}, - Test{cmplx(2, inf), cmplx(0, 1), cmplx(inf, nan)}, - Test{cmplx(2, inf), cmplx(0, -1), cmplx(-inf, nan)}, - Test{cmplx(2, inf), cmplx(0, 2), cmplx(inf, nan)}, - Test{cmplx(2, inf), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(1, 0), cmplx(nan, inf)}, - Test{cmplx(2, inf), cmplx(1, 1), cmplx(inf, inf)}, - Test{cmplx(2, inf), cmplx(1, -1), cmplx(-inf, inf)}, - Test{cmplx(2, inf), cmplx(1, 2), cmplx(inf, inf)}, - Test{cmplx(2, inf), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(-1, 0), cmplx(nan, -inf)}, - Test{cmplx(2, inf), cmplx(-1, 1), cmplx(inf, -inf)}, - Test{cmplx(2, inf), cmplx(-1, -1), cmplx(-inf, -inf)}, - Test{cmplx(2, inf), cmplx(-1, 2), cmplx(inf, -inf)}, - Test{cmplx(2, inf), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(2, 0), cmplx(nan, inf)}, - Test{cmplx(2, inf), cmplx(2, 1), cmplx(inf, inf)}, - Test{cmplx(2, inf), cmplx(2, -1), cmplx(-inf, inf)}, - Test{cmplx(2, inf), cmplx(2, 2), cmplx(inf, inf)}, - Test{cmplx(2, inf), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(0, 0), cmplx(inf, -inf)}, - Test{cmplx(2, -inf), cmplx(0, 1), cmplx(-inf, nan)}, - Test{cmplx(2, -inf), cmplx(0, -1), cmplx(inf, nan)}, - Test{cmplx(2, -inf), cmplx(0, 2), cmplx(-inf, nan)}, - Test{cmplx(2, -inf), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(1, 0), cmplx(nan, -inf)}, - Test{cmplx(2, -inf), cmplx(1, 1), cmplx(-inf, -inf)}, - Test{cmplx(2, -inf), cmplx(1, -1), cmplx(inf, -inf)}, - Test{cmplx(2, -inf), cmplx(1, 2), cmplx(-inf, -inf)}, - Test{cmplx(2, -inf), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(-1, 0), cmplx(nan, inf)}, - Test{cmplx(2, -inf), cmplx(-1, 1), cmplx(-inf, inf)}, - Test{cmplx(2, -inf), cmplx(-1, -1), cmplx(inf, inf)}, - Test{cmplx(2, -inf), cmplx(-1, 2), cmplx(-inf, inf)}, - Test{cmplx(2, -inf), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(2, 0), cmplx(nan, -inf)}, - Test{cmplx(2, -inf), cmplx(2, 1), cmplx(-inf, -inf)}, - Test{cmplx(2, -inf), cmplx(2, -1), cmplx(inf, -inf)}, - Test{cmplx(2, -inf), cmplx(2, 2), cmplx(-inf, -inf)}, - Test{cmplx(2, -inf), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(0, 0), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(0, 1), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(0, -1), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(0, 2), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(1, 0), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(1, 1), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(1, -1), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(1, 2), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(-1, 0), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(-1, 1), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(-1, -1), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(-1, 2), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(2, 0), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(2, 1), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(2, -1), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(2, 2), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(0, 0), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(0, 1), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(0, -1), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(0, 2), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(1, 0), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(1, 1), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(1, -1), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(1, 2), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(-1, 0), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(-1, 1), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(-1, -1), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(-1, 2), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(2, 0), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(2, 1), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(2, -1), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(2, 2), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(0, 0), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(0, 1), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(0, -1), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(0, 2), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(1, 0), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(1, 1), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(1, -1), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(1, 2), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(-1, 0), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(-1, 1), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(-1, -1), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(-1, 2), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(2, 0), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(2, 1), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(2, -1), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(2, 2), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(0, 0), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(0, 1), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(0, -1), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(0, 2), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(1, 0), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(1, 1), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(1, -1), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(1, 2), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(-1, 0), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(-1, 1), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(-1, -1), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(-1, 2), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(2, 0), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(2, 1), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(2, -1), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(2, 2), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(0, 0), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(0, 1), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(0, -1), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(0, 2), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(1, 0), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(1, 1), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(1, -1), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(1, 2), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(-1, 0), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(-1, 1), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(-1, -1), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(-1, 2), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(2, 0), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(2, 1), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(2, -1), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(2, 2), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(0, 0), cmplx(nan, inf)}, - Test{cmplx(nan, inf), cmplx(0, 1), cmplx(inf, nan)}, - Test{cmplx(nan, inf), cmplx(0, -1), cmplx(-inf, nan)}, - Test{cmplx(nan, inf), cmplx(0, 2), cmplx(inf, nan)}, - Test{cmplx(nan, inf), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(1, 0), cmplx(nan, inf)}, - Test{cmplx(nan, inf), cmplx(1, 1), cmplx(inf, inf)}, - Test{cmplx(nan, inf), cmplx(1, -1), cmplx(-inf, inf)}, - Test{cmplx(nan, inf), cmplx(1, 2), cmplx(inf, inf)}, - Test{cmplx(nan, inf), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(-1, 0), cmplx(nan, -inf)}, - Test{cmplx(nan, inf), cmplx(-1, 1), cmplx(inf, -inf)}, - Test{cmplx(nan, inf), cmplx(-1, -1), cmplx(-inf, -inf)}, - Test{cmplx(nan, inf), cmplx(-1, 2), cmplx(inf, -inf)}, - Test{cmplx(nan, inf), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(2, 0), cmplx(nan, inf)}, - Test{cmplx(nan, inf), cmplx(2, 1), cmplx(inf, inf)}, - Test{cmplx(nan, inf), cmplx(2, -1), cmplx(-inf, inf)}, - Test{cmplx(nan, inf), cmplx(2, 2), cmplx(inf, inf)}, - Test{cmplx(nan, inf), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(0, 0), cmplx(nan, -inf)}, - Test{cmplx(nan, -inf), cmplx(0, 1), cmplx(-inf, nan)}, - Test{cmplx(nan, -inf), cmplx(0, -1), cmplx(inf, nan)}, - Test{cmplx(nan, -inf), cmplx(0, 2), cmplx(-inf, nan)}, - Test{cmplx(nan, -inf), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(1, 0), cmplx(nan, -inf)}, - Test{cmplx(nan, -inf), cmplx(1, 1), cmplx(-inf, -inf)}, - Test{cmplx(nan, -inf), cmplx(1, -1), cmplx(inf, -inf)}, - Test{cmplx(nan, -inf), cmplx(1, 2), cmplx(-inf, -inf)}, - Test{cmplx(nan, -inf), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(-1, 0), cmplx(nan, inf)}, - Test{cmplx(nan, -inf), cmplx(-1, 1), cmplx(-inf, inf)}, - Test{cmplx(nan, -inf), cmplx(-1, -1), cmplx(inf, inf)}, - Test{cmplx(nan, -inf), cmplx(-1, 2), cmplx(-inf, inf)}, - Test{cmplx(nan, -inf), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(2, 0), cmplx(nan, -inf)}, - Test{cmplx(nan, -inf), cmplx(2, 1), cmplx(-inf, -inf)}, - Test{cmplx(nan, -inf), cmplx(2, -1), cmplx(inf, -inf)}, - Test{cmplx(nan, -inf), cmplx(2, 2), cmplx(-inf, -inf)}, - Test{cmplx(nan, -inf), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(0, 0), cmplx(inf, nan)}, - Test{cmplx(inf, 0), cmplx(0, 1), cmplx(nan, -inf)}, - Test{cmplx(inf, 0), cmplx(0, -1), cmplx(nan, inf)}, - Test{cmplx(inf, 0), cmplx(0, 2), cmplx(nan, -inf)}, - Test{cmplx(inf, 0), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(1, 0), cmplx(inf, nan)}, - Test{cmplx(inf, 0), cmplx(1, 1), cmplx(inf, -inf)}, - Test{cmplx(inf, 0), cmplx(1, -1), cmplx(inf, inf)}, - Test{cmplx(inf, 0), cmplx(1, 2), cmplx(inf, -inf)}, - Test{cmplx(inf, 0), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(-1, 0), cmplx(-inf, nan)}, - Test{cmplx(inf, 0), cmplx(-1, 1), cmplx(-inf, -inf)}, - Test{cmplx(inf, 0), cmplx(-1, -1), cmplx(-inf, inf)}, - Test{cmplx(inf, 0), cmplx(-1, 2), cmplx(-inf, -inf)}, - Test{cmplx(inf, 0), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(2, 0), cmplx(inf, nan)}, - Test{cmplx(inf, 0), cmplx(2, 1), cmplx(inf, -inf)}, - Test{cmplx(inf, 0), cmplx(2, -1), cmplx(inf, inf)}, - Test{cmplx(inf, 0), cmplx(2, 2), cmplx(inf, -inf)}, - Test{cmplx(inf, 0), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(0, 0), cmplx(inf, inf)}, - Test{cmplx(inf, 1), cmplx(0, 1), cmplx(nan, -inf)}, - Test{cmplx(inf, 1), cmplx(0, -1), cmplx(nan, inf)}, - Test{cmplx(inf, 1), cmplx(0, 2), cmplx(nan, -inf)}, - Test{cmplx(inf, 1), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(1, 0), cmplx(inf, nan)}, - Test{cmplx(inf, 1), cmplx(1, 1), cmplx(inf, -inf)}, - Test{cmplx(inf, 1), cmplx(1, -1), cmplx(inf, inf)}, - Test{cmplx(inf, 1), cmplx(1, 2), cmplx(inf, -inf)}, - Test{cmplx(inf, 1), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(-1, 0), cmplx(-inf, nan)}, - Test{cmplx(inf, 1), cmplx(-1, 1), cmplx(-inf, -inf)}, - Test{cmplx(inf, 1), cmplx(-1, -1), cmplx(-inf, inf)}, - Test{cmplx(inf, 1), cmplx(-1, 2), cmplx(-inf, -inf)}, - Test{cmplx(inf, 1), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(2, 0), cmplx(inf, nan)}, - Test{cmplx(inf, 1), cmplx(2, 1), cmplx(inf, -inf)}, - Test{cmplx(inf, 1), cmplx(2, -1), cmplx(inf, inf)}, - Test{cmplx(inf, 1), cmplx(2, 2), cmplx(inf, -inf)}, - Test{cmplx(inf, 1), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(0, 0), cmplx(inf, -inf)}, - Test{cmplx(inf, -1), cmplx(0, 1), cmplx(nan, -inf)}, - Test{cmplx(inf, -1), cmplx(0, -1), cmplx(nan, inf)}, - Test{cmplx(inf, -1), cmplx(0, 2), cmplx(nan, -inf)}, - Test{cmplx(inf, -1), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(1, 0), cmplx(inf, nan)}, - Test{cmplx(inf, -1), cmplx(1, 1), cmplx(inf, -inf)}, - Test{cmplx(inf, -1), cmplx(1, -1), cmplx(inf, inf)}, - Test{cmplx(inf, -1), cmplx(1, 2), cmplx(inf, -inf)}, - Test{cmplx(inf, -1), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(-1, 0), cmplx(-inf, nan)}, - Test{cmplx(inf, -1), cmplx(-1, 1), cmplx(-inf, -inf)}, - Test{cmplx(inf, -1), cmplx(-1, -1), cmplx(-inf, inf)}, - Test{cmplx(inf, -1), cmplx(-1, 2), cmplx(-inf, -inf)}, - Test{cmplx(inf, -1), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(2, 0), cmplx(inf, nan)}, - Test{cmplx(inf, -1), cmplx(2, 1), cmplx(inf, -inf)}, - Test{cmplx(inf, -1), cmplx(2, -1), cmplx(inf, inf)}, - Test{cmplx(inf, -1), cmplx(2, 2), cmplx(inf, -inf)}, - Test{cmplx(inf, -1), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(0, 0), cmplx(inf, inf)}, - Test{cmplx(inf, 2), cmplx(0, 1), cmplx(nan, -inf)}, - Test{cmplx(inf, 2), cmplx(0, -1), cmplx(nan, inf)}, - Test{cmplx(inf, 2), cmplx(0, 2), cmplx(nan, -inf)}, - Test{cmplx(inf, 2), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(1, 0), cmplx(inf, nan)}, - Test{cmplx(inf, 2), cmplx(1, 1), cmplx(inf, -inf)}, - Test{cmplx(inf, 2), cmplx(1, -1), cmplx(inf, inf)}, - Test{cmplx(inf, 2), cmplx(1, 2), cmplx(inf, -inf)}, - Test{cmplx(inf, 2), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(-1, 0), cmplx(-inf, nan)}, - Test{cmplx(inf, 2), cmplx(-1, 1), cmplx(-inf, -inf)}, - Test{cmplx(inf, 2), cmplx(-1, -1), cmplx(-inf, inf)}, - Test{cmplx(inf, 2), cmplx(-1, 2), cmplx(-inf, -inf)}, - Test{cmplx(inf, 2), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(2, 0), cmplx(inf, nan)}, - Test{cmplx(inf, 2), cmplx(2, 1), cmplx(inf, -inf)}, - Test{cmplx(inf, 2), cmplx(2, -1), cmplx(inf, inf)}, - Test{cmplx(inf, 2), cmplx(2, 2), cmplx(inf, -inf)}, - Test{cmplx(inf, 2), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(0, 0), cmplx(inf, nan)}, - Test{cmplx(inf, nan), cmplx(0, 1), cmplx(nan, -inf)}, - Test{cmplx(inf, nan), cmplx(0, -1), cmplx(nan, inf)}, - Test{cmplx(inf, nan), cmplx(0, 2), cmplx(nan, -inf)}, - Test{cmplx(inf, nan), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(1, 0), cmplx(inf, nan)}, - Test{cmplx(inf, nan), cmplx(1, 1), cmplx(inf, -inf)}, - Test{cmplx(inf, nan), cmplx(1, -1), cmplx(inf, inf)}, - Test{cmplx(inf, nan), cmplx(1, 2), cmplx(inf, -inf)}, - Test{cmplx(inf, nan), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(-1, 0), cmplx(-inf, nan)}, - Test{cmplx(inf, nan), cmplx(-1, 1), cmplx(-inf, -inf)}, - Test{cmplx(inf, nan), cmplx(-1, -1), cmplx(-inf, inf)}, - Test{cmplx(inf, nan), cmplx(-1, 2), cmplx(-inf, -inf)}, - Test{cmplx(inf, nan), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(2, 0), cmplx(inf, nan)}, - Test{cmplx(inf, nan), cmplx(2, 1), cmplx(inf, -inf)}, - Test{cmplx(inf, nan), cmplx(2, -1), cmplx(inf, inf)}, - Test{cmplx(inf, nan), cmplx(2, 2), cmplx(inf, -inf)}, - Test{cmplx(inf, nan), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(0, 0), cmplx(inf, inf)}, - Test{cmplx(inf, inf), cmplx(0, 1), cmplx(inf, -inf)}, - Test{cmplx(inf, inf), cmplx(0, -1), cmplx(-inf, inf)}, - Test{cmplx(inf, inf), cmplx(0, 2), cmplx(inf, -inf)}, - Test{cmplx(inf, inf), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(1, 0), cmplx(inf, inf)}, - Test{cmplx(inf, inf), cmplx(1, 1), cmplx(inf, nan)}, - Test{cmplx(inf, inf), cmplx(1, -1), cmplx(nan, inf)}, - Test{cmplx(inf, inf), cmplx(1, 2), cmplx(inf, nan)}, - Test{cmplx(inf, inf), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(-1, 0), cmplx(-inf, -inf)}, - Test{cmplx(inf, inf), cmplx(-1, 1), cmplx(nan, -inf)}, - Test{cmplx(inf, inf), cmplx(-1, -1), cmplx(-inf, nan)}, - Test{cmplx(inf, inf), cmplx(-1, 2), cmplx(nan, -inf)}, - Test{cmplx(inf, inf), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(2, 0), cmplx(inf, inf)}, - Test{cmplx(inf, inf), cmplx(2, 1), cmplx(inf, nan)}, - Test{cmplx(inf, inf), cmplx(2, -1), cmplx(nan, inf)}, - Test{cmplx(inf, inf), cmplx(2, 2), cmplx(inf, nan)}, - Test{cmplx(inf, inf), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(0, 0), cmplx(inf, -inf)}, - Test{cmplx(inf, -inf), cmplx(0, 1), cmplx(-inf, -inf)}, - Test{cmplx(inf, -inf), cmplx(0, -1), cmplx(inf, inf)}, - Test{cmplx(inf, -inf), cmplx(0, 2), cmplx(-inf, -inf)}, - Test{cmplx(inf, -inf), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(1, 0), cmplx(inf, -inf)}, - Test{cmplx(inf, -inf), cmplx(1, 1), cmplx(nan, -inf)}, - Test{cmplx(inf, -inf), cmplx(1, -1), cmplx(inf, nan)}, - Test{cmplx(inf, -inf), cmplx(1, 2), cmplx(nan, -inf)}, - Test{cmplx(inf, -inf), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(-1, 0), cmplx(-inf, inf)}, - Test{cmplx(inf, -inf), cmplx(-1, 1), cmplx(-inf, nan)}, - Test{cmplx(inf, -inf), cmplx(-1, -1), cmplx(nan, inf)}, - Test{cmplx(inf, -inf), cmplx(-1, 2), cmplx(-inf, nan)}, - Test{cmplx(inf, -inf), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(2, 0), cmplx(inf, -inf)}, - Test{cmplx(inf, -inf), cmplx(2, 1), cmplx(nan, -inf)}, - Test{cmplx(inf, -inf), cmplx(2, -1), cmplx(inf, nan)}, - Test{cmplx(inf, -inf), cmplx(2, 2), cmplx(nan, -inf)}, - Test{cmplx(inf, -inf), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(0, 0), cmplx(-inf, nan)}, - Test{cmplx(-inf, 0), cmplx(0, 1), cmplx(nan, inf)}, - Test{cmplx(-inf, 0), cmplx(0, -1), cmplx(nan, -inf)}, - Test{cmplx(-inf, 0), cmplx(0, 2), cmplx(nan, inf)}, - Test{cmplx(-inf, 0), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(1, 0), cmplx(-inf, nan)}, - Test{cmplx(-inf, 0), cmplx(1, 1), cmplx(-inf, inf)}, - Test{cmplx(-inf, 0), cmplx(1, -1), cmplx(-inf, -inf)}, - Test{cmplx(-inf, 0), cmplx(1, 2), cmplx(-inf, inf)}, - Test{cmplx(-inf, 0), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(-1, 0), cmplx(inf, nan)}, - Test{cmplx(-inf, 0), cmplx(-1, 1), cmplx(inf, inf)}, - Test{cmplx(-inf, 0), cmplx(-1, -1), cmplx(inf, -inf)}, - Test{cmplx(-inf, 0), cmplx(-1, 2), cmplx(inf, inf)}, - Test{cmplx(-inf, 0), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(2, 0), cmplx(-inf, nan)}, - Test{cmplx(-inf, 0), cmplx(2, 1), cmplx(-inf, inf)}, - Test{cmplx(-inf, 0), cmplx(2, -1), cmplx(-inf, -inf)}, - Test{cmplx(-inf, 0), cmplx(2, 2), cmplx(-inf, inf)}, - Test{cmplx(-inf, 0), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(0, 0), cmplx(-inf, inf)}, - Test{cmplx(-inf, 1), cmplx(0, 1), cmplx(nan, inf)}, - Test{cmplx(-inf, 1), cmplx(0, -1), cmplx(nan, -inf)}, - Test{cmplx(-inf, 1), cmplx(0, 2), cmplx(nan, inf)}, - Test{cmplx(-inf, 1), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(1, 0), cmplx(-inf, nan)}, - Test{cmplx(-inf, 1), cmplx(1, 1), cmplx(-inf, inf)}, - Test{cmplx(-inf, 1), cmplx(1, -1), cmplx(-inf, -inf)}, - Test{cmplx(-inf, 1), cmplx(1, 2), cmplx(-inf, inf)}, - Test{cmplx(-inf, 1), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(-1, 0), cmplx(inf, nan)}, - Test{cmplx(-inf, 1), cmplx(-1, 1), cmplx(inf, inf)}, - Test{cmplx(-inf, 1), cmplx(-1, -1), cmplx(inf, -inf)}, - Test{cmplx(-inf, 1), cmplx(-1, 2), cmplx(inf, inf)}, - Test{cmplx(-inf, 1), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(2, 0), cmplx(-inf, nan)}, - Test{cmplx(-inf, 1), cmplx(2, 1), cmplx(-inf, inf)}, - Test{cmplx(-inf, 1), cmplx(2, -1), cmplx(-inf, -inf)}, - Test{cmplx(-inf, 1), cmplx(2, 2), cmplx(-inf, inf)}, - Test{cmplx(-inf, 1), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(0, 0), cmplx(-inf, -inf)}, - Test{cmplx(-inf, -1), cmplx(0, 1), cmplx(nan, inf)}, - Test{cmplx(-inf, -1), cmplx(0, -1), cmplx(nan, -inf)}, - Test{cmplx(-inf, -1), cmplx(0, 2), cmplx(nan, inf)}, - Test{cmplx(-inf, -1), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(1, 0), cmplx(-inf, nan)}, - Test{cmplx(-inf, -1), cmplx(1, 1), cmplx(-inf, inf)}, - Test{cmplx(-inf, -1), cmplx(1, -1), cmplx(-inf, -inf)}, - Test{cmplx(-inf, -1), cmplx(1, 2), cmplx(-inf, inf)}, - Test{cmplx(-inf, -1), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(-1, 0), cmplx(inf, nan)}, - Test{cmplx(-inf, -1), cmplx(-1, 1), cmplx(inf, inf)}, - Test{cmplx(-inf, -1), cmplx(-1, -1), cmplx(inf, -inf)}, - Test{cmplx(-inf, -1), cmplx(-1, 2), cmplx(inf, inf)}, - Test{cmplx(-inf, -1), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(2, 0), cmplx(-inf, nan)}, - Test{cmplx(-inf, -1), cmplx(2, 1), cmplx(-inf, inf)}, - Test{cmplx(-inf, -1), cmplx(2, -1), cmplx(-inf, -inf)}, - Test{cmplx(-inf, -1), cmplx(2, 2), cmplx(-inf, inf)}, - Test{cmplx(-inf, -1), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(0, 0), cmplx(-inf, inf)}, - Test{cmplx(-inf, 2), cmplx(0, 1), cmplx(nan, inf)}, - Test{cmplx(-inf, 2), cmplx(0, -1), cmplx(nan, -inf)}, - Test{cmplx(-inf, 2), cmplx(0, 2), cmplx(nan, inf)}, - Test{cmplx(-inf, 2), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(1, 0), cmplx(-inf, nan)}, - Test{cmplx(-inf, 2), cmplx(1, 1), cmplx(-inf, inf)}, - Test{cmplx(-inf, 2), cmplx(1, -1), cmplx(-inf, -inf)}, - Test{cmplx(-inf, 2), cmplx(1, 2), cmplx(-inf, inf)}, - Test{cmplx(-inf, 2), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(-1, 0), cmplx(inf, nan)}, - Test{cmplx(-inf, 2), cmplx(-1, 1), cmplx(inf, inf)}, - Test{cmplx(-inf, 2), cmplx(-1, -1), cmplx(inf, -inf)}, - Test{cmplx(-inf, 2), cmplx(-1, 2), cmplx(inf, inf)}, - Test{cmplx(-inf, 2), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(2, 0), cmplx(-inf, nan)}, - Test{cmplx(-inf, 2), cmplx(2, 1), cmplx(-inf, inf)}, - Test{cmplx(-inf, 2), cmplx(2, -1), cmplx(-inf, -inf)}, - Test{cmplx(-inf, 2), cmplx(2, 2), cmplx(-inf, inf)}, - Test{cmplx(-inf, 2), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(0, 0), cmplx(-inf, nan)}, - Test{cmplx(-inf, nan), cmplx(0, 1), cmplx(nan, inf)}, - Test{cmplx(-inf, nan), cmplx(0, -1), cmplx(nan, -inf)}, - Test{cmplx(-inf, nan), cmplx(0, 2), cmplx(nan, inf)}, - Test{cmplx(-inf, nan), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(1, 0), cmplx(-inf, nan)}, - Test{cmplx(-inf, nan), cmplx(1, 1), cmplx(-inf, inf)}, - Test{cmplx(-inf, nan), cmplx(1, -1), cmplx(-inf, -inf)}, - Test{cmplx(-inf, nan), cmplx(1, 2), cmplx(-inf, inf)}, - Test{cmplx(-inf, nan), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(-1, 0), cmplx(inf, nan)}, - Test{cmplx(-inf, nan), cmplx(-1, 1), cmplx(inf, inf)}, - Test{cmplx(-inf, nan), cmplx(-1, -1), cmplx(inf, -inf)}, - Test{cmplx(-inf, nan), cmplx(-1, 2), cmplx(inf, inf)}, - Test{cmplx(-inf, nan), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(2, 0), cmplx(-inf, nan)}, - Test{cmplx(-inf, nan), cmplx(2, 1), cmplx(-inf, inf)}, - Test{cmplx(-inf, nan), cmplx(2, -1), cmplx(-inf, -inf)}, - Test{cmplx(-inf, nan), cmplx(2, 2), cmplx(-inf, inf)}, - Test{cmplx(-inf, nan), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(0, 0), cmplx(-inf, inf)}, - Test{cmplx(-inf, inf), cmplx(0, 1), cmplx(inf, inf)}, - Test{cmplx(-inf, inf), cmplx(0, -1), cmplx(-inf, -inf)}, - Test{cmplx(-inf, inf), cmplx(0, 2), cmplx(inf, inf)}, - Test{cmplx(-inf, inf), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(1, 0), cmplx(-inf, inf)}, - Test{cmplx(-inf, inf), cmplx(1, 1), cmplx(nan, inf)}, - Test{cmplx(-inf, inf), cmplx(1, -1), cmplx(-inf, nan)}, - Test{cmplx(-inf, inf), cmplx(1, 2), cmplx(nan, inf)}, - Test{cmplx(-inf, inf), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(-1, 0), cmplx(inf, -inf)}, - Test{cmplx(-inf, inf), cmplx(-1, 1), cmplx(inf, nan)}, - Test{cmplx(-inf, inf), cmplx(-1, -1), cmplx(nan, -inf)}, - Test{cmplx(-inf, inf), cmplx(-1, 2), cmplx(inf, nan)}, - Test{cmplx(-inf, inf), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(2, 0), cmplx(-inf, inf)}, - Test{cmplx(-inf, inf), cmplx(2, 1), cmplx(nan, inf)}, - Test{cmplx(-inf, inf), cmplx(2, -1), cmplx(-inf, nan)}, - Test{cmplx(-inf, inf), cmplx(2, 2), cmplx(nan, inf)}, - Test{cmplx(-inf, inf), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(0, 0), cmplx(-inf, -inf)}, - Test{cmplx(-inf, -inf), cmplx(0, 1), cmplx(-inf, inf)}, - Test{cmplx(-inf, -inf), cmplx(0, -1), cmplx(inf, -inf)}, - Test{cmplx(-inf, -inf), cmplx(0, 2), cmplx(-inf, inf)}, - Test{cmplx(-inf, -inf), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(1, 0), cmplx(-inf, -inf)}, - Test{cmplx(-inf, -inf), cmplx(1, 1), cmplx(-inf, nan)}, - Test{cmplx(-inf, -inf), cmplx(1, -1), cmplx(nan, -inf)}, - Test{cmplx(-inf, -inf), cmplx(1, 2), cmplx(-inf, nan)}, - Test{cmplx(-inf, -inf), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(-1, 0), cmplx(inf, inf)}, - Test{cmplx(-inf, -inf), cmplx(-1, 1), cmplx(nan, inf)}, - Test{cmplx(-inf, -inf), cmplx(-1, -1), cmplx(inf, nan)}, - Test{cmplx(-inf, -inf), cmplx(-1, 2), cmplx(nan, inf)}, - Test{cmplx(-inf, -inf), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(2, 0), cmplx(-inf, -inf)}, - Test{cmplx(-inf, -inf), cmplx(2, 1), cmplx(-inf, nan)}, - Test{cmplx(-inf, -inf), cmplx(2, -1), cmplx(nan, -inf)}, - Test{cmplx(-inf, -inf), cmplx(2, 2), cmplx(-inf, nan)}, - Test{cmplx(-inf, -inf), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(-inf, -inf), cmplx(nan, nan)}, + Test{complex(0, 0), complex(0, 0), complex(-nan, -nan)}, + Test{complex(0, 0), complex(0, 1), complex(0, 0)}, + Test{complex(0, 0), complex(0, -1), complex(negzero, 0)}, + Test{complex(0, 0), complex(0, 2), complex(0, 0)}, + Test{complex(0, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, 0), complex(-nan, inf), complex(0, negzero)}, + Test{complex(0, 0), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(0, 0), complex(1, 0), complex(0, 0)}, + Test{complex(0, 0), complex(1, 1), complex(0, 0)}, + Test{complex(0, 0), complex(1, -1), complex(0, 0)}, + Test{complex(0, 0), complex(1, 2), complex(0, 0)}, + Test{complex(0, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, 0), complex(-nan, inf), complex(0, negzero)}, + Test{complex(0, 0), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(0, 0), complex(-1, 0), complex(negzero, negzero)}, + Test{complex(0, 0), complex(-1, 1), complex(negzero, negzero)}, + Test{complex(0, 0), complex(-1, -1), complex(negzero, negzero)}, + Test{complex(0, 0), complex(-1, 2), complex(0, negzero)}, + Test{complex(0, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, 0), complex(-nan, inf), complex(0, negzero)}, + Test{complex(0, 0), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(0, 0), complex(2, 0), complex(0, 0)}, + Test{complex(0, 0), complex(2, 1), complex(0, 0)}, + Test{complex(0, 0), complex(2, -1), complex(0, 0)}, + Test{complex(0, 0), complex(2, 2), complex(0, 0)}, + Test{complex(0, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, 0), complex(-nan, inf), complex(0, negzero)}, + Test{complex(0, 0), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(0, 0), complex(nan, 0), complex(nan, nan)}, + Test{complex(0, 0), complex(nan, 1), complex(nan, nan)}, + Test{complex(0, 0), complex(nan, -1), complex(nan, nan)}, + Test{complex(0, 0), complex(nan, 2), complex(nan, nan)}, + Test{complex(0, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, 0), complex(-nan, inf), complex(0, negzero)}, + Test{complex(0, 0), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(0, 0), complex(inf, 0), complex(0, 0)}, + Test{complex(0, 0), complex(inf, 1), complex(0, 0)}, + Test{complex(0, 0), complex(inf, -1), complex(0, 0)}, + Test{complex(0, 0), complex(inf, 2), complex(0, 0)}, + Test{complex(0, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, 0), complex(-nan, inf), complex(0, negzero)}, + Test{complex(0, 0), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(0, 0), complex(-inf, 0), complex(negzero, negzero)}, + Test{complex(0, 0), complex(-inf, 1), complex(negzero, negzero)}, + Test{complex(0, 0), complex(-inf, -1), complex(negzero, negzero)}, + Test{complex(0, 0), complex(-inf, 2), complex(negzero, negzero)}, + Test{complex(0, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, 0), complex(-nan, inf), complex(0, negzero)}, + Test{complex(0, 0), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(0, 1), complex(0, 0), complex(-nan, inf)}, + Test{complex(0, 1), complex(0, 1), complex(1, 0)}, + Test{complex(0, 1), complex(0, -1), complex(-1, 0)}, + Test{complex(0, 1), complex(0, 2), complex(0.5, 0)}, + Test{complex(0, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, 1), complex(-nan, inf), complex(0, negzero)}, + Test{complex(0, 1), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(0, 1), complex(1, 0), complex(0, 1)}, + Test{complex(0, 1), complex(1, 1), complex(0.5, 0.5)}, + Test{complex(0, 1), complex(1, -1), complex(-0.5, 0.5)}, + Test{complex(0, 1), complex(1, 2), complex(0.4, 0.2)}, + Test{complex(0, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, 1), complex(-nan, inf), complex(0, negzero)}, + Test{complex(0, 1), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(0, 1), complex(-1, 0), complex(negzero, -1)}, + Test{complex(0, 1), complex(-1, 1), complex(0.5, -0.5)}, + Test{complex(0, 1), complex(-1, -1), complex(-0.5, -0.5)}, + Test{complex(0, 1), complex(-1, 2), complex(0.4, -0.2)}, + Test{complex(0, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, 1), complex(-nan, inf), complex(0, negzero)}, + Test{complex(0, 1), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(0, 1), complex(2, 0), complex(0, 0.5)}, + Test{complex(0, 1), complex(2, 1), complex(0.2, 0.4)}, + Test{complex(0, 1), complex(2, -1), complex(-0.2, 0.4)}, + Test{complex(0, 1), complex(2, 2), complex(0.25, 0.25)}, + Test{complex(0, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, 1), complex(-nan, inf), complex(0, negzero)}, + Test{complex(0, 1), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(0, 1), complex(nan, 0), complex(nan, nan)}, + Test{complex(0, 1), complex(nan, 1), complex(nan, nan)}, + Test{complex(0, 1), complex(nan, -1), complex(nan, nan)}, + Test{complex(0, 1), complex(nan, 2), complex(nan, nan)}, + Test{complex(0, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, 1), complex(-nan, inf), complex(0, negzero)}, + Test{complex(0, 1), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(0, 1), complex(inf, 0), complex(0, 0)}, + Test{complex(0, 1), complex(inf, 1), complex(0, 0)}, + Test{complex(0, 1), complex(inf, -1), complex(0, 0)}, + Test{complex(0, 1), complex(inf, 2), complex(0, 0)}, + Test{complex(0, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, 1), complex(-nan, inf), complex(0, negzero)}, + Test{complex(0, 1), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(0, 1), complex(-inf, 0), complex(negzero, negzero)}, + Test{complex(0, 1), complex(-inf, 1), complex(negzero, negzero)}, + Test{complex(0, 1), complex(-inf, -1), complex(negzero, negzero)}, + Test{complex(0, 1), complex(-inf, 2), complex(negzero, negzero)}, + Test{complex(0, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, 1), complex(-nan, inf), complex(0, negzero)}, + Test{complex(0, 1), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(0, -1), complex(0, 0), complex(-nan, -inf)}, + Test{complex(0, -1), complex(0, 1), complex(-1, negzero)}, + Test{complex(0, -1), complex(0, -1), complex(1, negzero)}, + Test{complex(0, -1), complex(0, 2), complex(-0.5, negzero)}, + Test{complex(0, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, -1), complex(-nan, inf), complex(negzero, 0)}, + Test{complex(0, -1), complex(-nan, -inf), complex(0, 0)}, + Test{complex(0, -1), complex(1, 0), complex(0, -1)}, + Test{complex(0, -1), complex(1, 1), complex(-0.5, -0.5)}, + Test{complex(0, -1), complex(1, -1), complex(0.5, -0.5)}, + Test{complex(0, -1), complex(1, 2), complex(-0.4, -0.2)}, + Test{complex(0, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, -1), complex(-nan, inf), complex(negzero, 0)}, + Test{complex(0, -1), complex(-nan, -inf), complex(0, 0)}, + Test{complex(0, -1), complex(-1, 0), complex(negzero, 1)}, + Test{complex(0, -1), complex(-1, 1), complex(-0.5, 0.5)}, + Test{complex(0, -1), complex(-1, -1), complex(0.5, 0.5)}, + Test{complex(0, -1), complex(-1, 2), complex(-0.4, 0.2)}, + Test{complex(0, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, -1), complex(-nan, inf), complex(negzero, 0)}, + Test{complex(0, -1), complex(-nan, -inf), complex(0, 0)}, + Test{complex(0, -1), complex(2, 0), complex(0, -0.5)}, + Test{complex(0, -1), complex(2, 1), complex(-0.2, -0.4)}, + Test{complex(0, -1), complex(2, -1), complex(0.2, -0.4)}, + Test{complex(0, -1), complex(2, 2), complex(-0.25, -0.25)}, + Test{complex(0, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, -1), complex(-nan, inf), complex(negzero, 0)}, + Test{complex(0, -1), complex(-nan, -inf), complex(0, 0)}, + Test{complex(0, -1), complex(nan, 0), complex(nan, nan)}, + Test{complex(0, -1), complex(nan, 1), complex(nan, nan)}, + Test{complex(0, -1), complex(nan, -1), complex(nan, nan)}, + Test{complex(0, -1), complex(nan, 2), complex(nan, nan)}, + Test{complex(0, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, -1), complex(-nan, inf), complex(negzero, 0)}, + Test{complex(0, -1), complex(-nan, -inf), complex(0, 0)}, + Test{complex(0, -1), complex(inf, 0), complex(0, negzero)}, + Test{complex(0, -1), complex(inf, 1), complex(0, negzero)}, + Test{complex(0, -1), complex(inf, -1), complex(0, negzero)}, + Test{complex(0, -1), complex(inf, 2), complex(0, negzero)}, + Test{complex(0, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, -1), complex(-nan, inf), complex(negzero, 0)}, + Test{complex(0, -1), complex(-nan, -inf), complex(0, 0)}, + Test{complex(0, -1), complex(-inf, 0), complex(negzero, 0)}, + Test{complex(0, -1), complex(-inf, 1), complex(negzero, 0)}, + Test{complex(0, -1), complex(-inf, -1), complex(negzero, 0)}, + Test{complex(0, -1), complex(-inf, 2), complex(negzero, 0)}, + Test{complex(0, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, -1), complex(-nan, inf), complex(negzero, 0)}, + Test{complex(0, -1), complex(-nan, -inf), complex(0, 0)}, + Test{complex(0, 2), complex(0, 0), complex(-nan, inf)}, + Test{complex(0, 2), complex(0, 1), complex(2, 0)}, + Test{complex(0, 2), complex(0, -1), complex(-2, 0)}, + Test{complex(0, 2), complex(0, 2), complex(1, 0)}, + Test{complex(0, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, 2), complex(-nan, inf), complex(0, negzero)}, + Test{complex(0, 2), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(0, 2), complex(1, 0), complex(0, 2)}, + Test{complex(0, 2), complex(1, 1), complex(1, 1)}, + Test{complex(0, 2), complex(1, -1), complex(-1, 1)}, + Test{complex(0, 2), complex(1, 2), complex(0.8, 0.4)}, + Test{complex(0, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, 2), complex(-nan, inf), complex(0, negzero)}, + Test{complex(0, 2), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(0, 2), complex(-1, 0), complex(negzero, -2)}, + Test{complex(0, 2), complex(-1, 1), complex(1, -1)}, + Test{complex(0, 2), complex(-1, -1), complex(-1, -1)}, + Test{complex(0, 2), complex(-1, 2), complex(0.8, -0.4)}, + Test{complex(0, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, 2), complex(-nan, inf), complex(0, negzero)}, + Test{complex(0, 2), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(0, 2), complex(2, 0), complex(0, 1)}, + Test{complex(0, 2), complex(2, 1), complex(0.4, 0.8)}, + Test{complex(0, 2), complex(2, -1), complex(-0.4, 0.8)}, + Test{complex(0, 2), complex(2, 2), complex(0.5, 0.5)}, + Test{complex(0, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, 2), complex(-nan, inf), complex(0, negzero)}, + Test{complex(0, 2), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(0, 2), complex(nan, 0), complex(nan, nan)}, + Test{complex(0, 2), complex(nan, 1), complex(nan, nan)}, + Test{complex(0, 2), complex(nan, -1), complex(nan, nan)}, + Test{complex(0, 2), complex(nan, 2), complex(nan, nan)}, + Test{complex(0, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, 2), complex(-nan, inf), complex(0, negzero)}, + Test{complex(0, 2), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(0, 2), complex(inf, 0), complex(0, 0)}, + Test{complex(0, 2), complex(inf, 1), complex(0, 0)}, + Test{complex(0, 2), complex(inf, -1), complex(0, 0)}, + Test{complex(0, 2), complex(inf, 2), complex(0, 0)}, + Test{complex(0, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, 2), complex(-nan, inf), complex(0, negzero)}, + Test{complex(0, 2), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(0, 2), complex(-inf, 0), complex(negzero, negzero)}, + Test{complex(0, 2), complex(-inf, 1), complex(negzero, negzero)}, + Test{complex(0, 2), complex(-inf, -1), complex(negzero, negzero)}, + Test{complex(0, 2), complex(-inf, 2), complex(negzero, negzero)}, + Test{complex(0, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, 2), complex(-nan, inf), complex(0, negzero)}, + Test{complex(0, 2), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(nan, nan), complex(0, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(0, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(0, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(0, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(-nan, inf), complex(0, 0), complex(-nan, inf)}, + Test{complex(-nan, inf), complex(0, 1), complex(inf, -nan)}, + Test{complex(-nan, inf), complex(0, -1), complex(-inf, -nan)}, + Test{complex(-nan, inf), complex(0, 2), complex(inf, -nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(1, 0), complex(-nan, inf)}, + Test{complex(-nan, inf), complex(1, 1), complex(inf, inf)}, + Test{complex(-nan, inf), complex(1, -1), complex(-inf, inf)}, + Test{complex(-nan, inf), complex(1, 2), complex(inf, inf)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-1, 0), complex(-nan, -inf)}, + Test{complex(-nan, inf), complex(-1, 1), complex(inf, -inf)}, + Test{complex(-nan, inf), complex(-1, -1), complex(-inf, -inf)}, + Test{complex(-nan, inf), complex(-1, 2), complex(inf, -inf)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(2, 0), complex(-nan, inf)}, + Test{complex(-nan, inf), complex(2, 1), complex(inf, inf)}, + Test{complex(-nan, inf), complex(2, -1), complex(-inf, inf)}, + Test{complex(-nan, inf), complex(2, 2), complex(inf, inf)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(nan, 0), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, 1), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, -1), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, 2), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(0, 0), complex(-nan, -inf)}, + Test{complex(-nan, -inf), complex(0, 1), complex(-inf, -nan)}, + Test{complex(-nan, -inf), complex(0, -1), complex(inf, -nan)}, + Test{complex(-nan, -inf), complex(0, 2), complex(-inf, -nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(1, 0), complex(-nan, -inf)}, + Test{complex(-nan, -inf), complex(1, 1), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(1, -1), complex(inf, -inf)}, + Test{complex(-nan, -inf), complex(1, 2), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-1, 0), complex(-nan, inf)}, + Test{complex(-nan, -inf), complex(-1, 1), complex(-inf, inf)}, + Test{complex(-nan, -inf), complex(-1, -1), complex(inf, inf)}, + Test{complex(-nan, -inf), complex(-1, 2), complex(-inf, inf)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(2, 0), complex(-nan, -inf)}, + Test{complex(-nan, -inf), complex(2, 1), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(2, -1), complex(inf, -inf)}, + Test{complex(-nan, -inf), complex(2, 2), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(nan, 0), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, 1), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, -1), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, 2), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(1, 0), complex(0, 0), complex(inf, -nan)}, + Test{complex(1, 0), complex(0, 1), complex(0, -1)}, + Test{complex(1, 0), complex(0, -1), complex(negzero, 1)}, + Test{complex(1, 0), complex(0, 2), complex(0, -0.5)}, + Test{complex(1, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, 0), complex(-nan, inf), complex(0, negzero)}, + Test{complex(1, 0), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(1, 0), complex(1, 0), complex(1, 0)}, + Test{complex(1, 0), complex(1, 1), complex(0.5, -0.5)}, + Test{complex(1, 0), complex(1, -1), complex(0.5, 0.5)}, + Test{complex(1, 0), complex(1, 2), complex(0.2, -0.4)}, + Test{complex(1, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, 0), complex(-nan, inf), complex(0, negzero)}, + Test{complex(1, 0), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(1, 0), complex(-1, 0), complex(-1, negzero)}, + Test{complex(1, 0), complex(-1, 1), complex(-0.5, -0.5)}, + Test{complex(1, 0), complex(-1, -1), complex(-0.5, 0.5)}, + Test{complex(1, 0), complex(-1, 2), complex(-0.2, -0.4)}, + Test{complex(1, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, 0), complex(-nan, inf), complex(0, negzero)}, + Test{complex(1, 0), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(1, 0), complex(2, 0), complex(0.5, 0)}, + Test{complex(1, 0), complex(2, 1), complex(0.4, -0.2)}, + Test{complex(1, 0), complex(2, -1), complex(0.4, 0.2)}, + Test{complex(1, 0), complex(2, 2), complex(0.25, -0.25)}, + Test{complex(1, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, 0), complex(-nan, inf), complex(0, negzero)}, + Test{complex(1, 0), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(1, 0), complex(nan, 0), complex(nan, nan)}, + Test{complex(1, 0), complex(nan, 1), complex(nan, nan)}, + Test{complex(1, 0), complex(nan, -1), complex(nan, nan)}, + Test{complex(1, 0), complex(nan, 2), complex(nan, nan)}, + Test{complex(1, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, 0), complex(-nan, inf), complex(0, negzero)}, + Test{complex(1, 0), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(1, 0), complex(inf, 0), complex(0, 0)}, + Test{complex(1, 0), complex(inf, 1), complex(0, 0)}, + Test{complex(1, 0), complex(inf, -1), complex(0, 0)}, + Test{complex(1, 0), complex(inf, 2), complex(0, 0)}, + Test{complex(1, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, 0), complex(-nan, inf), complex(0, negzero)}, + Test{complex(1, 0), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(1, 0), complex(-inf, 0), complex(negzero, negzero)}, + Test{complex(1, 0), complex(-inf, 1), complex(negzero, negzero)}, + Test{complex(1, 0), complex(-inf, -1), complex(negzero, negzero)}, + Test{complex(1, 0), complex(-inf, 2), complex(negzero, negzero)}, + Test{complex(1, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, 0), complex(-nan, inf), complex(0, negzero)}, + Test{complex(1, 0), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(1, 1), complex(0, 0), complex(inf, inf)}, + Test{complex(1, 1), complex(0, 1), complex(1, -1)}, + Test{complex(1, 1), complex(0, -1), complex(-1, 1)}, + Test{complex(1, 1), complex(0, 2), complex(0.5, -0.5)}, + Test{complex(1, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, 1), complex(-nan, inf), complex(0, negzero)}, + Test{complex(1, 1), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(1, 1), complex(1, 0), complex(1, 1)}, + Test{complex(1, 1), complex(1, 1), complex(1, 0)}, + Test{complex(1, 1), complex(1, -1), complex(0, 1)}, + Test{complex(1, 1), complex(1, 2), complex(0.6, -0.2)}, + Test{complex(1, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, 1), complex(-nan, inf), complex(0, negzero)}, + Test{complex(1, 1), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(1, 1), complex(-1, 0), complex(-1, -1)}, + Test{complex(1, 1), complex(-1, 1), complex(negzero, -1)}, + Test{complex(1, 1), complex(-1, -1), complex(-1, negzero)}, + Test{complex(1, 1), complex(-1, 2), complex(0.2, -0.6)}, + Test{complex(1, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, 1), complex(-nan, inf), complex(0, negzero)}, + Test{complex(1, 1), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(1, 1), complex(2, 0), complex(0.5, 0.5)}, + Test{complex(1, 1), complex(2, 1), complex(0.6, 0.2)}, + Test{complex(1, 1), complex(2, -1), complex(0.2, 0.6)}, + Test{complex(1, 1), complex(2, 2), complex(0.5, 0)}, + Test{complex(1, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, 1), complex(-nan, inf), complex(0, negzero)}, + Test{complex(1, 1), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(1, 1), complex(nan, 0), complex(nan, nan)}, + Test{complex(1, 1), complex(nan, 1), complex(nan, nan)}, + Test{complex(1, 1), complex(nan, -1), complex(nan, nan)}, + Test{complex(1, 1), complex(nan, 2), complex(nan, nan)}, + Test{complex(1, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, 1), complex(-nan, inf), complex(0, negzero)}, + Test{complex(1, 1), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(1, 1), complex(inf, 0), complex(0, 0)}, + Test{complex(1, 1), complex(inf, 1), complex(0, 0)}, + Test{complex(1, 1), complex(inf, -1), complex(0, 0)}, + Test{complex(1, 1), complex(inf, 2), complex(0, 0)}, + Test{complex(1, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, 1), complex(-nan, inf), complex(0, negzero)}, + Test{complex(1, 1), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(1, 1), complex(-inf, 0), complex(negzero, negzero)}, + Test{complex(1, 1), complex(-inf, 1), complex(negzero, negzero)}, + Test{complex(1, 1), complex(-inf, -1), complex(negzero, negzero)}, + Test{complex(1, 1), complex(-inf, 2), complex(negzero, negzero)}, + Test{complex(1, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, 1), complex(-nan, inf), complex(0, negzero)}, + Test{complex(1, 1), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(1, -1), complex(0, 0), complex(inf, -inf)}, + Test{complex(1, -1), complex(0, 1), complex(-1, -1)}, + Test{complex(1, -1), complex(0, -1), complex(1, 1)}, + Test{complex(1, -1), complex(0, 2), complex(-0.5, -0.5)}, + Test{complex(1, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, -1), complex(-nan, inf), complex(negzero, negzero)}, + Test{complex(1, -1), complex(-nan, -inf), complex(0, 0)}, + Test{complex(1, -1), complex(1, 0), complex(1, -1)}, + Test{complex(1, -1), complex(1, 1), complex(0, -1)}, + Test{complex(1, -1), complex(1, -1), complex(1, 0)}, + Test{complex(1, -1), complex(1, 2), complex(-0.2, -0.6)}, + Test{complex(1, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, -1), complex(-nan, inf), complex(negzero, negzero)}, + Test{complex(1, -1), complex(-nan, -inf), complex(0, 0)}, + Test{complex(1, -1), complex(-1, 0), complex(-1, 1)}, + Test{complex(1, -1), complex(-1, 1), complex(-1, negzero)}, + Test{complex(1, -1), complex(-1, -1), complex(negzero, 1)}, + Test{complex(1, -1), complex(-1, 2), complex(-0.6, -0.2)}, + Test{complex(1, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, -1), complex(-nan, inf), complex(negzero, negzero)}, + Test{complex(1, -1), complex(-nan, -inf), complex(0, 0)}, + Test{complex(1, -1), complex(2, 0), complex(0.5, -0.5)}, + Test{complex(1, -1), complex(2, 1), complex(0.2, -0.6)}, + Test{complex(1, -1), complex(2, -1), complex(0.6, -0.2)}, + Test{complex(1, -1), complex(2, 2), complex(0, -0.5)}, + Test{complex(1, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, -1), complex(-nan, inf), complex(negzero, negzero)}, + Test{complex(1, -1), complex(-nan, -inf), complex(0, 0)}, + Test{complex(1, -1), complex(nan, 0), complex(nan, nan)}, + Test{complex(1, -1), complex(nan, 1), complex(nan, nan)}, + Test{complex(1, -1), complex(nan, -1), complex(nan, nan)}, + Test{complex(1, -1), complex(nan, 2), complex(nan, nan)}, + Test{complex(1, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, -1), complex(-nan, inf), complex(negzero, negzero)}, + Test{complex(1, -1), complex(-nan, -inf), complex(0, 0)}, + Test{complex(1, -1), complex(inf, 0), complex(0, negzero)}, + Test{complex(1, -1), complex(inf, 1), complex(0, negzero)}, + Test{complex(1, -1), complex(inf, -1), complex(0, negzero)}, + Test{complex(1, -1), complex(inf, 2), complex(0, negzero)}, + Test{complex(1, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, -1), complex(-nan, inf), complex(negzero, negzero)}, + Test{complex(1, -1), complex(-nan, -inf), complex(0, 0)}, + Test{complex(1, -1), complex(-inf, 0), complex(negzero, 0)}, + Test{complex(1, -1), complex(-inf, 1), complex(negzero, 0)}, + Test{complex(1, -1), complex(-inf, -1), complex(negzero, 0)}, + Test{complex(1, -1), complex(-inf, 2), complex(negzero, 0)}, + Test{complex(1, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, -1), complex(-nan, inf), complex(negzero, negzero)}, + Test{complex(1, -1), complex(-nan, -inf), complex(0, 0)}, + Test{complex(1, 2), complex(0, 0), complex(inf, inf)}, + Test{complex(1, 2), complex(0, 1), complex(2, -1)}, + Test{complex(1, 2), complex(0, -1), complex(-2, 1)}, + Test{complex(1, 2), complex(0, 2), complex(1, -0.5)}, + Test{complex(1, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, 2), complex(-nan, inf), complex(0, negzero)}, + Test{complex(1, 2), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(1, 2), complex(1, 0), complex(1, 2)}, + Test{complex(1, 2), complex(1, 1), complex(1.5, 0.5)}, + Test{complex(1, 2), complex(1, -1), complex(-0.5, 1.5)}, + Test{complex(1, 2), complex(1, 2), complex(1, 0)}, + Test{complex(1, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, 2), complex(-nan, inf), complex(0, negzero)}, + Test{complex(1, 2), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(1, 2), complex(-1, 0), complex(-1, -2)}, + Test{complex(1, 2), complex(-1, 1), complex(0.5, -1.5)}, + Test{complex(1, 2), complex(-1, -1), complex(-1.5, -0.5)}, + Test{complex(1, 2), complex(-1, 2), complex(0.6, -0.8)}, + Test{complex(1, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, 2), complex(-nan, inf), complex(0, negzero)}, + Test{complex(1, 2), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(1, 2), complex(2, 0), complex(0.5, 1)}, + Test{complex(1, 2), complex(2, 1), complex(0.8, 0.6)}, + Test{complex(1, 2), complex(2, -1), complex(0, 1)}, + Test{complex(1, 2), complex(2, 2), complex(0.75, 0.25)}, + Test{complex(1, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, 2), complex(-nan, inf), complex(0, negzero)}, + Test{complex(1, 2), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(1, 2), complex(nan, 0), complex(nan, nan)}, + Test{complex(1, 2), complex(nan, 1), complex(nan, nan)}, + Test{complex(1, 2), complex(nan, -1), complex(nan, nan)}, + Test{complex(1, 2), complex(nan, 2), complex(nan, nan)}, + Test{complex(1, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, 2), complex(-nan, inf), complex(0, negzero)}, + Test{complex(1, 2), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(1, 2), complex(inf, 0), complex(0, 0)}, + Test{complex(1, 2), complex(inf, 1), complex(0, 0)}, + Test{complex(1, 2), complex(inf, -1), complex(0, 0)}, + Test{complex(1, 2), complex(inf, 2), complex(0, 0)}, + Test{complex(1, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, 2), complex(-nan, inf), complex(0, negzero)}, + Test{complex(1, 2), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(1, 2), complex(-inf, 0), complex(negzero, negzero)}, + Test{complex(1, 2), complex(-inf, 1), complex(negzero, negzero)}, + Test{complex(1, 2), complex(-inf, -1), complex(negzero, negzero)}, + Test{complex(1, 2), complex(-inf, 2), complex(negzero, negzero)}, + Test{complex(1, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, 2), complex(-nan, inf), complex(0, negzero)}, + Test{complex(1, 2), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(nan, nan), complex(0, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(0, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(0, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(0, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(-nan, inf), complex(0, 0), complex(-nan, inf)}, + Test{complex(-nan, inf), complex(0, 1), complex(inf, -nan)}, + Test{complex(-nan, inf), complex(0, -1), complex(-inf, -nan)}, + Test{complex(-nan, inf), complex(0, 2), complex(inf, -nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(1, 0), complex(-nan, inf)}, + Test{complex(-nan, inf), complex(1, 1), complex(inf, inf)}, + Test{complex(-nan, inf), complex(1, -1), complex(-inf, inf)}, + Test{complex(-nan, inf), complex(1, 2), complex(inf, inf)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-1, 0), complex(-nan, -inf)}, + Test{complex(-nan, inf), complex(-1, 1), complex(inf, -inf)}, + Test{complex(-nan, inf), complex(-1, -1), complex(-inf, -inf)}, + Test{complex(-nan, inf), complex(-1, 2), complex(inf, -inf)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(2, 0), complex(-nan, inf)}, + Test{complex(-nan, inf), complex(2, 1), complex(inf, inf)}, + Test{complex(-nan, inf), complex(2, -1), complex(-inf, inf)}, + Test{complex(-nan, inf), complex(2, 2), complex(inf, inf)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(nan, 0), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, 1), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, -1), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, 2), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(0, 0), complex(-nan, -inf)}, + Test{complex(-nan, -inf), complex(0, 1), complex(-inf, -nan)}, + Test{complex(-nan, -inf), complex(0, -1), complex(inf, -nan)}, + Test{complex(-nan, -inf), complex(0, 2), complex(-inf, -nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(1, 0), complex(-nan, -inf)}, + Test{complex(-nan, -inf), complex(1, 1), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(1, -1), complex(inf, -inf)}, + Test{complex(-nan, -inf), complex(1, 2), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-1, 0), complex(-nan, inf)}, + Test{complex(-nan, -inf), complex(-1, 1), complex(-inf, inf)}, + Test{complex(-nan, -inf), complex(-1, -1), complex(inf, inf)}, + Test{complex(-nan, -inf), complex(-1, 2), complex(-inf, inf)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(2, 0), complex(-nan, -inf)}, + Test{complex(-nan, -inf), complex(2, 1), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(2, -1), complex(inf, -inf)}, + Test{complex(-nan, -inf), complex(2, 2), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(nan, 0), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, 1), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, -1), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, 2), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-1, 0), complex(0, 0), complex(-inf, -nan)}, + Test{complex(-1, 0), complex(0, 1), complex(0, 1)}, + Test{complex(-1, 0), complex(0, -1), complex(negzero, -1)}, + Test{complex(-1, 0), complex(0, 2), complex(0, 0.5)}, + Test{complex(-1, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, 0), complex(-nan, inf), complex(0, 0)}, + Test{complex(-1, 0), complex(-nan, -inf), complex(0, negzero)}, + Test{complex(-1, 0), complex(1, 0), complex(-1, 0)}, + Test{complex(-1, 0), complex(1, 1), complex(-0.5, 0.5)}, + Test{complex(-1, 0), complex(1, -1), complex(-0.5, -0.5)}, + Test{complex(-1, 0), complex(1, 2), complex(-0.2, 0.4)}, + Test{complex(-1, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, 0), complex(-nan, inf), complex(0, 0)}, + Test{complex(-1, 0), complex(-nan, -inf), complex(0, negzero)}, + Test{complex(-1, 0), complex(-1, 0), complex(1, negzero)}, + Test{complex(-1, 0), complex(-1, 1), complex(0.5, 0.5)}, + Test{complex(-1, 0), complex(-1, -1), complex(0.5, -0.5)}, + Test{complex(-1, 0), complex(-1, 2), complex(0.2, 0.4)}, + Test{complex(-1, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, 0), complex(-nan, inf), complex(0, 0)}, + Test{complex(-1, 0), complex(-nan, -inf), complex(0, negzero)}, + Test{complex(-1, 0), complex(2, 0), complex(-0.5, 0)}, + Test{complex(-1, 0), complex(2, 1), complex(-0.4, 0.2)}, + Test{complex(-1, 0), complex(2, -1), complex(-0.4, -0.2)}, + Test{complex(-1, 0), complex(2, 2), complex(-0.25, 0.25)}, + Test{complex(-1, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, 0), complex(-nan, inf), complex(0, 0)}, + Test{complex(-1, 0), complex(-nan, -inf), complex(0, negzero)}, + Test{complex(-1, 0), complex(nan, 0), complex(nan, nan)}, + Test{complex(-1, 0), complex(nan, 1), complex(nan, nan)}, + Test{complex(-1, 0), complex(nan, -1), complex(nan, nan)}, + Test{complex(-1, 0), complex(nan, 2), complex(nan, nan)}, + Test{complex(-1, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, 0), complex(-nan, inf), complex(0, 0)}, + Test{complex(-1, 0), complex(-nan, -inf), complex(0, negzero)}, + Test{complex(-1, 0), complex(inf, 0), complex(negzero, 0)}, + Test{complex(-1, 0), complex(inf, 1), complex(negzero, 0)}, + Test{complex(-1, 0), complex(inf, -1), complex(negzero, 0)}, + Test{complex(-1, 0), complex(inf, 2), complex(negzero, 0)}, + Test{complex(-1, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, 0), complex(-nan, inf), complex(0, 0)}, + Test{complex(-1, 0), complex(-nan, -inf), complex(0, negzero)}, + Test{complex(-1, 0), complex(-inf, 0), complex(0, negzero)}, + Test{complex(-1, 0), complex(-inf, 1), complex(0, negzero)}, + Test{complex(-1, 0), complex(-inf, -1), complex(0, negzero)}, + Test{complex(-1, 0), complex(-inf, 2), complex(0, negzero)}, + Test{complex(-1, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, 0), complex(-nan, inf), complex(0, 0)}, + Test{complex(-1, 0), complex(-nan, -inf), complex(0, negzero)}, + Test{complex(-1, 1), complex(0, 0), complex(-inf, inf)}, + Test{complex(-1, 1), complex(0, 1), complex(1, 1)}, + Test{complex(-1, 1), complex(0, -1), complex(-1, -1)}, + Test{complex(-1, 1), complex(0, 2), complex(0.5, 0.5)}, + Test{complex(-1, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, 1), complex(-nan, inf), complex(0, 0)}, + Test{complex(-1, 1), complex(-nan, -inf), complex(negzero, negzero)}, + Test{complex(-1, 1), complex(1, 0), complex(-1, 1)}, + Test{complex(-1, 1), complex(1, 1), complex(0, 1)}, + Test{complex(-1, 1), complex(1, -1), complex(-1, 0)}, + Test{complex(-1, 1), complex(1, 2), complex(0.2, 0.6)}, + Test{complex(-1, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, 1), complex(-nan, inf), complex(0, 0)}, + Test{complex(-1, 1), complex(-nan, -inf), complex(negzero, negzero)}, + Test{complex(-1, 1), complex(-1, 0), complex(1, -1)}, + Test{complex(-1, 1), complex(-1, 1), complex(1, negzero)}, + Test{complex(-1, 1), complex(-1, -1), complex(negzero, -1)}, + Test{complex(-1, 1), complex(-1, 2), complex(0.6, 0.2)}, + Test{complex(-1, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, 1), complex(-nan, inf), complex(0, 0)}, + Test{complex(-1, 1), complex(-nan, -inf), complex(negzero, negzero)}, + Test{complex(-1, 1), complex(2, 0), complex(-0.5, 0.5)}, + Test{complex(-1, 1), complex(2, 1), complex(-0.2, 0.6)}, + Test{complex(-1, 1), complex(2, -1), complex(-0.6, 0.2)}, + Test{complex(-1, 1), complex(2, 2), complex(0, 0.5)}, + Test{complex(-1, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, 1), complex(-nan, inf), complex(0, 0)}, + Test{complex(-1, 1), complex(-nan, -inf), complex(negzero, negzero)}, + Test{complex(-1, 1), complex(nan, 0), complex(nan, nan)}, + Test{complex(-1, 1), complex(nan, 1), complex(nan, nan)}, + Test{complex(-1, 1), complex(nan, -1), complex(nan, nan)}, + Test{complex(-1, 1), complex(nan, 2), complex(nan, nan)}, + Test{complex(-1, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, 1), complex(-nan, inf), complex(0, 0)}, + Test{complex(-1, 1), complex(-nan, -inf), complex(negzero, negzero)}, + Test{complex(-1, 1), complex(inf, 0), complex(negzero, 0)}, + Test{complex(-1, 1), complex(inf, 1), complex(negzero, 0)}, + Test{complex(-1, 1), complex(inf, -1), complex(negzero, 0)}, + Test{complex(-1, 1), complex(inf, 2), complex(negzero, 0)}, + Test{complex(-1, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, 1), complex(-nan, inf), complex(0, 0)}, + Test{complex(-1, 1), complex(-nan, -inf), complex(negzero, negzero)}, + Test{complex(-1, 1), complex(-inf, 0), complex(0, negzero)}, + Test{complex(-1, 1), complex(-inf, 1), complex(0, negzero)}, + Test{complex(-1, 1), complex(-inf, -1), complex(0, negzero)}, + Test{complex(-1, 1), complex(-inf, 2), complex(0, negzero)}, + Test{complex(-1, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, 1), complex(-nan, inf), complex(0, 0)}, + Test{complex(-1, 1), complex(-nan, -inf), complex(negzero, negzero)}, + Test{complex(-1, -1), complex(0, 0), complex(-inf, -inf)}, + Test{complex(-1, -1), complex(0, 1), complex(-1, 1)}, + Test{complex(-1, -1), complex(0, -1), complex(1, -1)}, + Test{complex(-1, -1), complex(0, 2), complex(-0.5, 0.5)}, + Test{complex(-1, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, -1), complex(-nan, inf), complex(negzero, 0)}, + Test{complex(-1, -1), complex(-nan, -inf), complex(0, negzero)}, + Test{complex(-1, -1), complex(1, 0), complex(-1, -1)}, + Test{complex(-1, -1), complex(1, 1), complex(-1, 0)}, + Test{complex(-1, -1), complex(1, -1), complex(0, -1)}, + Test{complex(-1, -1), complex(1, 2), complex(-0.6, 0.2)}, + Test{complex(-1, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, -1), complex(-nan, inf), complex(negzero, 0)}, + Test{complex(-1, -1), complex(-nan, -inf), complex(0, negzero)}, + Test{complex(-1, -1), complex(-1, 0), complex(1, 1)}, + Test{complex(-1, -1), complex(-1, 1), complex(negzero, 1)}, + Test{complex(-1, -1), complex(-1, -1), complex(1, negzero)}, + Test{complex(-1, -1), complex(-1, 2), complex(-0.2, 0.6)}, + Test{complex(-1, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, -1), complex(-nan, inf), complex(negzero, 0)}, + Test{complex(-1, -1), complex(-nan, -inf), complex(0, negzero)}, + Test{complex(-1, -1), complex(2, 0), complex(-0.5, -0.5)}, + Test{complex(-1, -1), complex(2, 1), complex(-0.6, -0.2)}, + Test{complex(-1, -1), complex(2, -1), complex(-0.2, -0.6)}, + Test{complex(-1, -1), complex(2, 2), complex(-0.5, 0)}, + Test{complex(-1, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, -1), complex(-nan, inf), complex(negzero, 0)}, + Test{complex(-1, -1), complex(-nan, -inf), complex(0, negzero)}, + Test{complex(-1, -1), complex(nan, 0), complex(nan, nan)}, + Test{complex(-1, -1), complex(nan, 1), complex(nan, nan)}, + Test{complex(-1, -1), complex(nan, -1), complex(nan, nan)}, + Test{complex(-1, -1), complex(nan, 2), complex(nan, nan)}, + Test{complex(-1, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, -1), complex(-nan, inf), complex(negzero, 0)}, + Test{complex(-1, -1), complex(-nan, -inf), complex(0, negzero)}, + Test{complex(-1, -1), complex(inf, 0), complex(negzero, negzero)}, + Test{complex(-1, -1), complex(inf, 1), complex(negzero, negzero)}, + Test{complex(-1, -1), complex(inf, -1), complex(negzero, negzero)}, + Test{complex(-1, -1), complex(inf, 2), complex(negzero, negzero)}, + Test{complex(-1, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, -1), complex(-nan, inf), complex(negzero, 0)}, + Test{complex(-1, -1), complex(-nan, -inf), complex(0, negzero)}, + Test{complex(-1, -1), complex(-inf, 0), complex(0, 0)}, + Test{complex(-1, -1), complex(-inf, 1), complex(0, 0)}, + Test{complex(-1, -1), complex(-inf, -1), complex(0, 0)}, + Test{complex(-1, -1), complex(-inf, 2), complex(0, 0)}, + Test{complex(-1, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, -1), complex(-nan, inf), complex(negzero, 0)}, + Test{complex(-1, -1), complex(-nan, -inf), complex(0, negzero)}, + Test{complex(-1, 2), complex(0, 0), complex(-inf, inf)}, + Test{complex(-1, 2), complex(0, 1), complex(2, 1)}, + Test{complex(-1, 2), complex(0, -1), complex(-2, -1)}, + Test{complex(-1, 2), complex(0, 2), complex(1, 0.5)}, + Test{complex(-1, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, 2), complex(-nan, inf), complex(0, 0)}, + Test{complex(-1, 2), complex(-nan, -inf), complex(negzero, negzero)}, + Test{complex(-1, 2), complex(1, 0), complex(-1, 2)}, + Test{complex(-1, 2), complex(1, 1), complex(0.5, 1.5)}, + Test{complex(-1, 2), complex(1, -1), complex(-1.5, 0.5)}, + Test{complex(-1, 2), complex(1, 2), complex(0.6, 0.8)}, + Test{complex(-1, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, 2), complex(-nan, inf), complex(0, 0)}, + Test{complex(-1, 2), complex(-nan, -inf), complex(negzero, negzero)}, + Test{complex(-1, 2), complex(-1, 0), complex(1, -2)}, + Test{complex(-1, 2), complex(-1, 1), complex(1.5, -0.5)}, + Test{complex(-1, 2), complex(-1, -1), complex(-0.5, -1.5)}, + Test{complex(-1, 2), complex(-1, 2), complex(1, 0)}, + Test{complex(-1, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, 2), complex(-nan, inf), complex(0, 0)}, + Test{complex(-1, 2), complex(-nan, -inf), complex(negzero, negzero)}, + Test{complex(-1, 2), complex(2, 0), complex(-0.5, 1)}, + Test{complex(-1, 2), complex(2, 1), complex(0, 1)}, + Test{complex(-1, 2), complex(2, -1), complex(-0.8, 0.6)}, + Test{complex(-1, 2), complex(2, 2), complex(0.25, 0.75)}, + Test{complex(-1, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, 2), complex(-nan, inf), complex(0, 0)}, + Test{complex(-1, 2), complex(-nan, -inf), complex(negzero, negzero)}, + Test{complex(-1, 2), complex(nan, 0), complex(nan, nan)}, + Test{complex(-1, 2), complex(nan, 1), complex(nan, nan)}, + Test{complex(-1, 2), complex(nan, -1), complex(nan, nan)}, + Test{complex(-1, 2), complex(nan, 2), complex(nan, nan)}, + Test{complex(-1, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, 2), complex(-nan, inf), complex(0, 0)}, + Test{complex(-1, 2), complex(-nan, -inf), complex(negzero, negzero)}, + Test{complex(-1, 2), complex(inf, 0), complex(negzero, 0)}, + Test{complex(-1, 2), complex(inf, 1), complex(negzero, 0)}, + Test{complex(-1, 2), complex(inf, -1), complex(negzero, 0)}, + Test{complex(-1, 2), complex(inf, 2), complex(negzero, 0)}, + Test{complex(-1, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, 2), complex(-nan, inf), complex(0, 0)}, + Test{complex(-1, 2), complex(-nan, -inf), complex(negzero, negzero)}, + Test{complex(-1, 2), complex(-inf, 0), complex(0, negzero)}, + Test{complex(-1, 2), complex(-inf, 1), complex(0, negzero)}, + Test{complex(-1, 2), complex(-inf, -1), complex(0, negzero)}, + Test{complex(-1, 2), complex(-inf, 2), complex(0, negzero)}, + Test{complex(-1, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, 2), complex(-nan, inf), complex(0, 0)}, + Test{complex(-1, 2), complex(-nan, -inf), complex(negzero, negzero)}, + Test{complex(nan, nan), complex(0, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(0, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(0, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(0, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(-nan, inf), complex(0, 0), complex(-nan, inf)}, + Test{complex(-nan, inf), complex(0, 1), complex(inf, -nan)}, + Test{complex(-nan, inf), complex(0, -1), complex(-inf, -nan)}, + Test{complex(-nan, inf), complex(0, 2), complex(inf, -nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(1, 0), complex(-nan, inf)}, + Test{complex(-nan, inf), complex(1, 1), complex(inf, inf)}, + Test{complex(-nan, inf), complex(1, -1), complex(-inf, inf)}, + Test{complex(-nan, inf), complex(1, 2), complex(inf, inf)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-1, 0), complex(-nan, -inf)}, + Test{complex(-nan, inf), complex(-1, 1), complex(inf, -inf)}, + Test{complex(-nan, inf), complex(-1, -1), complex(-inf, -inf)}, + Test{complex(-nan, inf), complex(-1, 2), complex(inf, -inf)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(2, 0), complex(-nan, inf)}, + Test{complex(-nan, inf), complex(2, 1), complex(inf, inf)}, + Test{complex(-nan, inf), complex(2, -1), complex(-inf, inf)}, + Test{complex(-nan, inf), complex(2, 2), complex(inf, inf)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(nan, 0), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, 1), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, -1), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, 2), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(0, 0), complex(-nan, -inf)}, + Test{complex(-nan, -inf), complex(0, 1), complex(-inf, -nan)}, + Test{complex(-nan, -inf), complex(0, -1), complex(inf, -nan)}, + Test{complex(-nan, -inf), complex(0, 2), complex(-inf, -nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(1, 0), complex(-nan, -inf)}, + Test{complex(-nan, -inf), complex(1, 1), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(1, -1), complex(inf, -inf)}, + Test{complex(-nan, -inf), complex(1, 2), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-1, 0), complex(-nan, inf)}, + Test{complex(-nan, -inf), complex(-1, 1), complex(-inf, inf)}, + Test{complex(-nan, -inf), complex(-1, -1), complex(inf, inf)}, + Test{complex(-nan, -inf), complex(-1, 2), complex(-inf, inf)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(2, 0), complex(-nan, -inf)}, + Test{complex(-nan, -inf), complex(2, 1), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(2, -1), complex(inf, -inf)}, + Test{complex(-nan, -inf), complex(2, 2), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(nan, 0), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, 1), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, -1), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, 2), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(2, 0), complex(0, 0), complex(inf, -nan)}, + Test{complex(2, 0), complex(0, 1), complex(0, -2)}, + Test{complex(2, 0), complex(0, -1), complex(negzero, 2)}, + Test{complex(2, 0), complex(0, 2), complex(0, -1)}, + Test{complex(2, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, 0), complex(-nan, inf), complex(0, negzero)}, + Test{complex(2, 0), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(2, 0), complex(1, 0), complex(2, 0)}, + Test{complex(2, 0), complex(1, 1), complex(1, -1)}, + Test{complex(2, 0), complex(1, -1), complex(1, 1)}, + Test{complex(2, 0), complex(1, 2), complex(0.4, -0.8)}, + Test{complex(2, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, 0), complex(-nan, inf), complex(0, negzero)}, + Test{complex(2, 0), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(2, 0), complex(-1, 0), complex(-2, negzero)}, + Test{complex(2, 0), complex(-1, 1), complex(-1, -1)}, + Test{complex(2, 0), complex(-1, -1), complex(-1, 1)}, + Test{complex(2, 0), complex(-1, 2), complex(-0.4, -0.8)}, + Test{complex(2, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, 0), complex(-nan, inf), complex(0, negzero)}, + Test{complex(2, 0), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(2, 0), complex(2, 0), complex(1, 0)}, + Test{complex(2, 0), complex(2, 1), complex(0.8, -0.4)}, + Test{complex(2, 0), complex(2, -1), complex(0.8, 0.4)}, + Test{complex(2, 0), complex(2, 2), complex(0.5, -0.5)}, + Test{complex(2, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, 0), complex(-nan, inf), complex(0, negzero)}, + Test{complex(2, 0), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(2, 0), complex(nan, 0), complex(nan, nan)}, + Test{complex(2, 0), complex(nan, 1), complex(nan, nan)}, + Test{complex(2, 0), complex(nan, -1), complex(nan, nan)}, + Test{complex(2, 0), complex(nan, 2), complex(nan, nan)}, + Test{complex(2, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, 0), complex(-nan, inf), complex(0, negzero)}, + Test{complex(2, 0), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(2, 0), complex(inf, 0), complex(0, 0)}, + Test{complex(2, 0), complex(inf, 1), complex(0, 0)}, + Test{complex(2, 0), complex(inf, -1), complex(0, 0)}, + Test{complex(2, 0), complex(inf, 2), complex(0, 0)}, + Test{complex(2, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, 0), complex(-nan, inf), complex(0, negzero)}, + Test{complex(2, 0), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(2, 0), complex(-inf, 0), complex(negzero, negzero)}, + Test{complex(2, 0), complex(-inf, 1), complex(negzero, negzero)}, + Test{complex(2, 0), complex(-inf, -1), complex(negzero, negzero)}, + Test{complex(2, 0), complex(-inf, 2), complex(negzero, negzero)}, + Test{complex(2, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, 0), complex(-nan, inf), complex(0, negzero)}, + Test{complex(2, 0), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(2, 1), complex(0, 0), complex(inf, inf)}, + Test{complex(2, 1), complex(0, 1), complex(1, -2)}, + Test{complex(2, 1), complex(0, -1), complex(-1, 2)}, + Test{complex(2, 1), complex(0, 2), complex(0.5, -1)}, + Test{complex(2, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, 1), complex(-nan, inf), complex(0, negzero)}, + Test{complex(2, 1), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(2, 1), complex(1, 0), complex(2, 1)}, + Test{complex(2, 1), complex(1, 1), complex(1.5, -0.5)}, + Test{complex(2, 1), complex(1, -1), complex(0.5, 1.5)}, + Test{complex(2, 1), complex(1, 2), complex(0.8, -0.6)}, + Test{complex(2, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, 1), complex(-nan, inf), complex(0, negzero)}, + Test{complex(2, 1), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(2, 1), complex(-1, 0), complex(-2, -1)}, + Test{complex(2, 1), complex(-1, 1), complex(-0.5, -1.5)}, + Test{complex(2, 1), complex(-1, -1), complex(-1.5, 0.5)}, + Test{complex(2, 1), complex(-1, 2), complex(0, -1)}, + Test{complex(2, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, 1), complex(-nan, inf), complex(0, negzero)}, + Test{complex(2, 1), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(2, 1), complex(2, 0), complex(1, 0.5)}, + Test{complex(2, 1), complex(2, 1), complex(1, 0)}, + Test{complex(2, 1), complex(2, -1), complex(0.6, 0.8)}, + Test{complex(2, 1), complex(2, 2), complex(0.75, -0.25)}, + Test{complex(2, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, 1), complex(-nan, inf), complex(0, negzero)}, + Test{complex(2, 1), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(2, 1), complex(nan, 0), complex(nan, nan)}, + Test{complex(2, 1), complex(nan, 1), complex(nan, nan)}, + Test{complex(2, 1), complex(nan, -1), complex(nan, nan)}, + Test{complex(2, 1), complex(nan, 2), complex(nan, nan)}, + Test{complex(2, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, 1), complex(-nan, inf), complex(0, negzero)}, + Test{complex(2, 1), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(2, 1), complex(inf, 0), complex(0, 0)}, + Test{complex(2, 1), complex(inf, 1), complex(0, 0)}, + Test{complex(2, 1), complex(inf, -1), complex(0, 0)}, + Test{complex(2, 1), complex(inf, 2), complex(0, 0)}, + Test{complex(2, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, 1), complex(-nan, inf), complex(0, negzero)}, + Test{complex(2, 1), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(2, 1), complex(-inf, 0), complex(negzero, negzero)}, + Test{complex(2, 1), complex(-inf, 1), complex(negzero, negzero)}, + Test{complex(2, 1), complex(-inf, -1), complex(negzero, negzero)}, + Test{complex(2, 1), complex(-inf, 2), complex(negzero, negzero)}, + Test{complex(2, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, 1), complex(-nan, inf), complex(0, negzero)}, + Test{complex(2, 1), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(2, -1), complex(0, 0), complex(inf, -inf)}, + Test{complex(2, -1), complex(0, 1), complex(-1, -2)}, + Test{complex(2, -1), complex(0, -1), complex(1, 2)}, + Test{complex(2, -1), complex(0, 2), complex(-0.5, -1)}, + Test{complex(2, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, -1), complex(-nan, inf), complex(negzero, negzero)}, + Test{complex(2, -1), complex(-nan, -inf), complex(0, 0)}, + Test{complex(2, -1), complex(1, 0), complex(2, -1)}, + Test{complex(2, -1), complex(1, 1), complex(0.5, -1.5)}, + Test{complex(2, -1), complex(1, -1), complex(1.5, 0.5)}, + Test{complex(2, -1), complex(1, 2), complex(0, -1)}, + Test{complex(2, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, -1), complex(-nan, inf), complex(negzero, negzero)}, + Test{complex(2, -1), complex(-nan, -inf), complex(0, 0)}, + Test{complex(2, -1), complex(-1, 0), complex(-2, 1)}, + Test{complex(2, -1), complex(-1, 1), complex(-1.5, -0.5)}, + Test{complex(2, -1), complex(-1, -1), complex(-0.5, 1.5)}, + Test{complex(2, -1), complex(-1, 2), complex(-0.8, -0.6)}, + Test{complex(2, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, -1), complex(-nan, inf), complex(negzero, negzero)}, + Test{complex(2, -1), complex(-nan, -inf), complex(0, 0)}, + Test{complex(2, -1), complex(2, 0), complex(1, -0.5)}, + Test{complex(2, -1), complex(2, 1), complex(0.6, -0.8)}, + Test{complex(2, -1), complex(2, -1), complex(1, 0)}, + Test{complex(2, -1), complex(2, 2), complex(0.25, -0.75)}, + Test{complex(2, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, -1), complex(-nan, inf), complex(negzero, negzero)}, + Test{complex(2, -1), complex(-nan, -inf), complex(0, 0)}, + Test{complex(2, -1), complex(nan, 0), complex(nan, nan)}, + Test{complex(2, -1), complex(nan, 1), complex(nan, nan)}, + Test{complex(2, -1), complex(nan, -1), complex(nan, nan)}, + Test{complex(2, -1), complex(nan, 2), complex(nan, nan)}, + Test{complex(2, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, -1), complex(-nan, inf), complex(negzero, negzero)}, + Test{complex(2, -1), complex(-nan, -inf), complex(0, 0)}, + Test{complex(2, -1), complex(inf, 0), complex(0, negzero)}, + Test{complex(2, -1), complex(inf, 1), complex(0, negzero)}, + Test{complex(2, -1), complex(inf, -1), complex(0, negzero)}, + Test{complex(2, -1), complex(inf, 2), complex(0, negzero)}, + Test{complex(2, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, -1), complex(-nan, inf), complex(negzero, negzero)}, + Test{complex(2, -1), complex(-nan, -inf), complex(0, 0)}, + Test{complex(2, -1), complex(-inf, 0), complex(negzero, 0)}, + Test{complex(2, -1), complex(-inf, 1), complex(negzero, 0)}, + Test{complex(2, -1), complex(-inf, -1), complex(negzero, 0)}, + Test{complex(2, -1), complex(-inf, 2), complex(negzero, 0)}, + Test{complex(2, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, -1), complex(-nan, inf), complex(negzero, negzero)}, + Test{complex(2, -1), complex(-nan, -inf), complex(0, 0)}, + Test{complex(2, 2), complex(0, 0), complex(inf, inf)}, + Test{complex(2, 2), complex(0, 1), complex(2, -2)}, + Test{complex(2, 2), complex(0, -1), complex(-2, 2)}, + Test{complex(2, 2), complex(0, 2), complex(1, -1)}, + Test{complex(2, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, 2), complex(-nan, inf), complex(0, negzero)}, + Test{complex(2, 2), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(2, 2), complex(1, 0), complex(2, 2)}, + Test{complex(2, 2), complex(1, 1), complex(2, 0)}, + Test{complex(2, 2), complex(1, -1), complex(0, 2)}, + Test{complex(2, 2), complex(1, 2), complex(1.2, -0.4)}, + Test{complex(2, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, 2), complex(-nan, inf), complex(0, negzero)}, + Test{complex(2, 2), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(2, 2), complex(-1, 0), complex(-2, -2)}, + Test{complex(2, 2), complex(-1, 1), complex(negzero, -2)}, + Test{complex(2, 2), complex(-1, -1), complex(-2, negzero)}, + Test{complex(2, 2), complex(-1, 2), complex(0.4, -1.2)}, + Test{complex(2, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, 2), complex(-nan, inf), complex(0, negzero)}, + Test{complex(2, 2), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(2, 2), complex(2, 0), complex(1, 1)}, + Test{complex(2, 2), complex(2, 1), complex(1.2, 0.4)}, + Test{complex(2, 2), complex(2, -1), complex(0.4, 1.2)}, + Test{complex(2, 2), complex(2, 2), complex(1, 0)}, + Test{complex(2, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, 2), complex(-nan, inf), complex(0, negzero)}, + Test{complex(2, 2), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(2, 2), complex(nan, 0), complex(nan, nan)}, + Test{complex(2, 2), complex(nan, 1), complex(nan, nan)}, + Test{complex(2, 2), complex(nan, -1), complex(nan, nan)}, + Test{complex(2, 2), complex(nan, 2), complex(nan, nan)}, + Test{complex(2, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, 2), complex(-nan, inf), complex(0, negzero)}, + Test{complex(2, 2), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(2, 2), complex(inf, 0), complex(0, 0)}, + Test{complex(2, 2), complex(inf, 1), complex(0, 0)}, + Test{complex(2, 2), complex(inf, -1), complex(0, 0)}, + Test{complex(2, 2), complex(inf, 2), complex(0, 0)}, + Test{complex(2, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, 2), complex(-nan, inf), complex(0, negzero)}, + Test{complex(2, 2), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(2, 2), complex(-inf, 0), complex(negzero, negzero)}, + Test{complex(2, 2), complex(-inf, 1), complex(negzero, negzero)}, + Test{complex(2, 2), complex(-inf, -1), complex(negzero, negzero)}, + Test{complex(2, 2), complex(-inf, 2), complex(negzero, negzero)}, + Test{complex(2, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, 2), complex(-nan, inf), complex(0, negzero)}, + Test{complex(2, 2), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(nan, nan), complex(0, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(0, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(0, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(0, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(-nan, inf), complex(0, 0), complex(-nan, inf)}, + Test{complex(-nan, inf), complex(0, 1), complex(inf, -nan)}, + Test{complex(-nan, inf), complex(0, -1), complex(-inf, -nan)}, + Test{complex(-nan, inf), complex(0, 2), complex(inf, -nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(1, 0), complex(-nan, inf)}, + Test{complex(-nan, inf), complex(1, 1), complex(inf, inf)}, + Test{complex(-nan, inf), complex(1, -1), complex(-inf, inf)}, + Test{complex(-nan, inf), complex(1, 2), complex(inf, inf)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-1, 0), complex(-nan, -inf)}, + Test{complex(-nan, inf), complex(-1, 1), complex(inf, -inf)}, + Test{complex(-nan, inf), complex(-1, -1), complex(-inf, -inf)}, + Test{complex(-nan, inf), complex(-1, 2), complex(inf, -inf)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(2, 0), complex(-nan, inf)}, + Test{complex(-nan, inf), complex(2, 1), complex(inf, inf)}, + Test{complex(-nan, inf), complex(2, -1), complex(-inf, inf)}, + Test{complex(-nan, inf), complex(2, 2), complex(inf, inf)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(nan, 0), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, 1), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, -1), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, 2), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(0, 0), complex(-nan, -inf)}, + Test{complex(-nan, -inf), complex(0, 1), complex(-inf, -nan)}, + Test{complex(-nan, -inf), complex(0, -1), complex(inf, -nan)}, + Test{complex(-nan, -inf), complex(0, 2), complex(-inf, -nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(1, 0), complex(-nan, -inf)}, + Test{complex(-nan, -inf), complex(1, 1), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(1, -1), complex(inf, -inf)}, + Test{complex(-nan, -inf), complex(1, 2), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-1, 0), complex(-nan, inf)}, + Test{complex(-nan, -inf), complex(-1, 1), complex(-inf, inf)}, + Test{complex(-nan, -inf), complex(-1, -1), complex(inf, inf)}, + Test{complex(-nan, -inf), complex(-1, 2), complex(-inf, inf)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(2, 0), complex(-nan, -inf)}, + Test{complex(-nan, -inf), complex(2, 1), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(2, -1), complex(inf, -inf)}, + Test{complex(-nan, -inf), complex(2, 2), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(nan, 0), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, 1), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, -1), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, 2), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, 0), complex(0, 0), complex(nan, nan)}, + Test{complex(nan, 0), complex(0, 1), complex(nan, nan)}, + Test{complex(nan, 0), complex(0, -1), complex(nan, nan)}, + Test{complex(nan, 0), complex(0, 2), complex(nan, nan)}, + Test{complex(nan, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, 0), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, 0), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, 0), complex(1, 0), complex(nan, nan)}, + Test{complex(nan, 0), complex(1, 1), complex(nan, nan)}, + Test{complex(nan, 0), complex(1, -1), complex(nan, nan)}, + Test{complex(nan, 0), complex(1, 2), complex(nan, nan)}, + Test{complex(nan, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, 0), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, 0), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, 0), complex(-1, 0), complex(nan, nan)}, + Test{complex(nan, 0), complex(-1, 1), complex(nan, nan)}, + Test{complex(nan, 0), complex(-1, -1), complex(nan, nan)}, + Test{complex(nan, 0), complex(-1, 2), complex(nan, nan)}, + Test{complex(nan, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, 0), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, 0), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, 0), complex(2, 0), complex(nan, nan)}, + Test{complex(nan, 0), complex(2, 1), complex(nan, nan)}, + Test{complex(nan, 0), complex(2, -1), complex(nan, nan)}, + Test{complex(nan, 0), complex(2, 2), complex(nan, nan)}, + Test{complex(nan, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, 0), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, 0), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, 0), complex(nan, 0), complex(nan, nan)}, + Test{complex(nan, 0), complex(nan, 1), complex(nan, nan)}, + Test{complex(nan, 0), complex(nan, -1), complex(nan, nan)}, + Test{complex(nan, 0), complex(nan, 2), complex(nan, nan)}, + Test{complex(nan, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, 0), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, 0), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, 0), complex(inf, 0), complex(nan, nan)}, + Test{complex(nan, 0), complex(inf, 1), complex(nan, nan)}, + Test{complex(nan, 0), complex(inf, -1), complex(nan, nan)}, + Test{complex(nan, 0), complex(inf, 2), complex(nan, nan)}, + Test{complex(nan, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, 0), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, 0), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, 0), complex(-inf, 0), complex(nan, nan)}, + Test{complex(nan, 0), complex(-inf, 1), complex(nan, nan)}, + Test{complex(nan, 0), complex(-inf, -1), complex(nan, nan)}, + Test{complex(nan, 0), complex(-inf, 2), complex(nan, nan)}, + Test{complex(nan, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, 0), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, 0), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, 1), complex(0, 0), complex(nan, nan)}, + Test{complex(nan, 1), complex(0, 1), complex(nan, nan)}, + Test{complex(nan, 1), complex(0, -1), complex(nan, nan)}, + Test{complex(nan, 1), complex(0, 2), complex(nan, nan)}, + Test{complex(nan, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, 1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, 1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, 1), complex(1, 0), complex(nan, nan)}, + Test{complex(nan, 1), complex(1, 1), complex(nan, nan)}, + Test{complex(nan, 1), complex(1, -1), complex(nan, nan)}, + Test{complex(nan, 1), complex(1, 2), complex(nan, nan)}, + Test{complex(nan, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, 1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, 1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, 1), complex(-1, 0), complex(nan, nan)}, + Test{complex(nan, 1), complex(-1, 1), complex(nan, nan)}, + Test{complex(nan, 1), complex(-1, -1), complex(nan, nan)}, + Test{complex(nan, 1), complex(-1, 2), complex(nan, nan)}, + Test{complex(nan, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, 1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, 1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, 1), complex(2, 0), complex(nan, nan)}, + Test{complex(nan, 1), complex(2, 1), complex(nan, nan)}, + Test{complex(nan, 1), complex(2, -1), complex(nan, nan)}, + Test{complex(nan, 1), complex(2, 2), complex(nan, nan)}, + Test{complex(nan, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, 1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, 1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, 1), complex(nan, 0), complex(nan, nan)}, + Test{complex(nan, 1), complex(nan, 1), complex(nan, nan)}, + Test{complex(nan, 1), complex(nan, -1), complex(nan, nan)}, + Test{complex(nan, 1), complex(nan, 2), complex(nan, nan)}, + Test{complex(nan, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, 1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, 1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, 1), complex(inf, 0), complex(nan, nan)}, + Test{complex(nan, 1), complex(inf, 1), complex(nan, nan)}, + Test{complex(nan, 1), complex(inf, -1), complex(nan, nan)}, + Test{complex(nan, 1), complex(inf, 2), complex(nan, nan)}, + Test{complex(nan, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, 1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, 1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, 1), complex(-inf, 0), complex(nan, nan)}, + Test{complex(nan, 1), complex(-inf, 1), complex(nan, nan)}, + Test{complex(nan, 1), complex(-inf, -1), complex(nan, nan)}, + Test{complex(nan, 1), complex(-inf, 2), complex(nan, nan)}, + Test{complex(nan, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, 1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, 1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, -1), complex(0, 0), complex(nan, nan)}, + Test{complex(nan, -1), complex(0, 1), complex(nan, nan)}, + Test{complex(nan, -1), complex(0, -1), complex(nan, nan)}, + Test{complex(nan, -1), complex(0, 2), complex(nan, nan)}, + Test{complex(nan, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, -1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, -1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, -1), complex(1, 0), complex(nan, nan)}, + Test{complex(nan, -1), complex(1, 1), complex(nan, nan)}, + Test{complex(nan, -1), complex(1, -1), complex(nan, nan)}, + Test{complex(nan, -1), complex(1, 2), complex(nan, nan)}, + Test{complex(nan, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, -1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, -1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, -1), complex(-1, 0), complex(nan, nan)}, + Test{complex(nan, -1), complex(-1, 1), complex(nan, nan)}, + Test{complex(nan, -1), complex(-1, -1), complex(nan, nan)}, + Test{complex(nan, -1), complex(-1, 2), complex(nan, nan)}, + Test{complex(nan, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, -1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, -1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, -1), complex(2, 0), complex(nan, nan)}, + Test{complex(nan, -1), complex(2, 1), complex(nan, nan)}, + Test{complex(nan, -1), complex(2, -1), complex(nan, nan)}, + Test{complex(nan, -1), complex(2, 2), complex(nan, nan)}, + Test{complex(nan, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, -1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, -1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, -1), complex(nan, 0), complex(nan, nan)}, + Test{complex(nan, -1), complex(nan, 1), complex(nan, nan)}, + Test{complex(nan, -1), complex(nan, -1), complex(nan, nan)}, + Test{complex(nan, -1), complex(nan, 2), complex(nan, nan)}, + Test{complex(nan, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, -1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, -1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, -1), complex(inf, 0), complex(nan, nan)}, + Test{complex(nan, -1), complex(inf, 1), complex(nan, nan)}, + Test{complex(nan, -1), complex(inf, -1), complex(nan, nan)}, + Test{complex(nan, -1), complex(inf, 2), complex(nan, nan)}, + Test{complex(nan, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, -1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, -1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, -1), complex(-inf, 0), complex(nan, nan)}, + Test{complex(nan, -1), complex(-inf, 1), complex(nan, nan)}, + Test{complex(nan, -1), complex(-inf, -1), complex(nan, nan)}, + Test{complex(nan, -1), complex(-inf, 2), complex(nan, nan)}, + Test{complex(nan, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, -1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, -1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, 2), complex(0, 0), complex(nan, nan)}, + Test{complex(nan, 2), complex(0, 1), complex(nan, nan)}, + Test{complex(nan, 2), complex(0, -1), complex(nan, nan)}, + Test{complex(nan, 2), complex(0, 2), complex(nan, nan)}, + Test{complex(nan, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, 2), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, 2), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, 2), complex(1, 0), complex(nan, nan)}, + Test{complex(nan, 2), complex(1, 1), complex(nan, nan)}, + Test{complex(nan, 2), complex(1, -1), complex(nan, nan)}, + Test{complex(nan, 2), complex(1, 2), complex(nan, nan)}, + Test{complex(nan, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, 2), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, 2), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, 2), complex(-1, 0), complex(nan, nan)}, + Test{complex(nan, 2), complex(-1, 1), complex(nan, nan)}, + Test{complex(nan, 2), complex(-1, -1), complex(nan, nan)}, + Test{complex(nan, 2), complex(-1, 2), complex(nan, nan)}, + Test{complex(nan, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, 2), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, 2), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, 2), complex(2, 0), complex(nan, nan)}, + Test{complex(nan, 2), complex(2, 1), complex(nan, nan)}, + Test{complex(nan, 2), complex(2, -1), complex(nan, nan)}, + Test{complex(nan, 2), complex(2, 2), complex(nan, nan)}, + Test{complex(nan, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, 2), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, 2), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, 2), complex(nan, 0), complex(nan, nan)}, + Test{complex(nan, 2), complex(nan, 1), complex(nan, nan)}, + Test{complex(nan, 2), complex(nan, -1), complex(nan, nan)}, + Test{complex(nan, 2), complex(nan, 2), complex(nan, nan)}, + Test{complex(nan, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, 2), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, 2), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, 2), complex(inf, 0), complex(nan, nan)}, + Test{complex(nan, 2), complex(inf, 1), complex(nan, nan)}, + Test{complex(nan, 2), complex(inf, -1), complex(nan, nan)}, + Test{complex(nan, 2), complex(inf, 2), complex(nan, nan)}, + Test{complex(nan, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, 2), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, 2), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, 2), complex(-inf, 0), complex(nan, nan)}, + Test{complex(nan, 2), complex(-inf, 1), complex(nan, nan)}, + Test{complex(nan, 2), complex(-inf, -1), complex(nan, nan)}, + Test{complex(nan, 2), complex(-inf, 2), complex(nan, nan)}, + Test{complex(nan, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, 2), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, 2), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, nan), complex(0, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(0, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(0, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(0, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(-nan, inf), complex(0, 0), complex(-nan, inf)}, + Test{complex(-nan, inf), complex(0, 1), complex(inf, -nan)}, + Test{complex(-nan, inf), complex(0, -1), complex(-inf, -nan)}, + Test{complex(-nan, inf), complex(0, 2), complex(inf, -nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(1, 0), complex(-nan, inf)}, + Test{complex(-nan, inf), complex(1, 1), complex(inf, inf)}, + Test{complex(-nan, inf), complex(1, -1), complex(-inf, inf)}, + Test{complex(-nan, inf), complex(1, 2), complex(inf, inf)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-1, 0), complex(-nan, -inf)}, + Test{complex(-nan, inf), complex(-1, 1), complex(inf, -inf)}, + Test{complex(-nan, inf), complex(-1, -1), complex(-inf, -inf)}, + Test{complex(-nan, inf), complex(-1, 2), complex(inf, -inf)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(2, 0), complex(-nan, inf)}, + Test{complex(-nan, inf), complex(2, 1), complex(inf, inf)}, + Test{complex(-nan, inf), complex(2, -1), complex(-inf, inf)}, + Test{complex(-nan, inf), complex(2, 2), complex(inf, inf)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(nan, 0), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, 1), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, -1), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, 2), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(0, 0), complex(-nan, -inf)}, + Test{complex(-nan, -inf), complex(0, 1), complex(-inf, -nan)}, + Test{complex(-nan, -inf), complex(0, -1), complex(inf, -nan)}, + Test{complex(-nan, -inf), complex(0, 2), complex(-inf, -nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(1, 0), complex(-nan, -inf)}, + Test{complex(-nan, -inf), complex(1, 1), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(1, -1), complex(inf, -inf)}, + Test{complex(-nan, -inf), complex(1, 2), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-1, 0), complex(-nan, inf)}, + Test{complex(-nan, -inf), complex(-1, 1), complex(-inf, inf)}, + Test{complex(-nan, -inf), complex(-1, -1), complex(inf, inf)}, + Test{complex(-nan, -inf), complex(-1, 2), complex(-inf, inf)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(2, 0), complex(-nan, -inf)}, + Test{complex(-nan, -inf), complex(2, 1), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(2, -1), complex(inf, -inf)}, + Test{complex(-nan, -inf), complex(2, 2), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(nan, 0), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, 1), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, -1), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, 2), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, 0), complex(0, 0), complex(inf, -nan)}, + Test{complex(inf, 0), complex(0, 1), complex(-nan, -inf)}, + Test{complex(inf, 0), complex(0, -1), complex(-nan, inf)}, + Test{complex(inf, 0), complex(0, 2), complex(-nan, -inf)}, + Test{complex(inf, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, 0), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, 0), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, 0), complex(1, 0), complex(inf, -nan)}, + Test{complex(inf, 0), complex(1, 1), complex(inf, -inf)}, + Test{complex(inf, 0), complex(1, -1), complex(inf, inf)}, + Test{complex(inf, 0), complex(1, 2), complex(inf, -inf)}, + Test{complex(inf, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, 0), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, 0), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, 0), complex(-1, 0), complex(-inf, -nan)}, + Test{complex(inf, 0), complex(-1, 1), complex(-inf, -inf)}, + Test{complex(inf, 0), complex(-1, -1), complex(-inf, inf)}, + Test{complex(inf, 0), complex(-1, 2), complex(-inf, -inf)}, + Test{complex(inf, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, 0), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, 0), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, 0), complex(2, 0), complex(inf, -nan)}, + Test{complex(inf, 0), complex(2, 1), complex(inf, -inf)}, + Test{complex(inf, 0), complex(2, -1), complex(inf, inf)}, + Test{complex(inf, 0), complex(2, 2), complex(inf, -inf)}, + Test{complex(inf, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, 0), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, 0), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, 0), complex(nan, 0), complex(nan, nan)}, + Test{complex(inf, 0), complex(nan, 1), complex(nan, nan)}, + Test{complex(inf, 0), complex(nan, -1), complex(nan, nan)}, + Test{complex(inf, 0), complex(nan, 2), complex(nan, nan)}, + Test{complex(inf, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, 0), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, 0), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, 0), complex(inf, 0), complex(-nan, -nan)}, + Test{complex(inf, 0), complex(inf, 1), complex(-nan, -nan)}, + Test{complex(inf, 0), complex(inf, -1), complex(-nan, -nan)}, + Test{complex(inf, 0), complex(inf, 2), complex(-nan, -nan)}, + Test{complex(inf, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, 0), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, 0), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, 0), complex(-inf, 0), complex(-nan, -nan)}, + Test{complex(inf, 0), complex(-inf, 1), complex(-nan, -nan)}, + Test{complex(inf, 0), complex(-inf, -1), complex(-nan, -nan)}, + Test{complex(inf, 0), complex(-inf, 2), complex(-nan, -nan)}, + Test{complex(inf, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, 0), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, 0), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, 1), complex(0, 0), complex(inf, inf)}, + Test{complex(inf, 1), complex(0, 1), complex(-nan, -inf)}, + Test{complex(inf, 1), complex(0, -1), complex(-nan, inf)}, + Test{complex(inf, 1), complex(0, 2), complex(-nan, -inf)}, + Test{complex(inf, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, 1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, 1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, 1), complex(1, 0), complex(inf, -nan)}, + Test{complex(inf, 1), complex(1, 1), complex(inf, -inf)}, + Test{complex(inf, 1), complex(1, -1), complex(inf, inf)}, + Test{complex(inf, 1), complex(1, 2), complex(inf, -inf)}, + Test{complex(inf, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, 1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, 1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, 1), complex(-1, 0), complex(-inf, -nan)}, + Test{complex(inf, 1), complex(-1, 1), complex(-inf, -inf)}, + Test{complex(inf, 1), complex(-1, -1), complex(-inf, inf)}, + Test{complex(inf, 1), complex(-1, 2), complex(-inf, -inf)}, + Test{complex(inf, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, 1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, 1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, 1), complex(2, 0), complex(inf, -nan)}, + Test{complex(inf, 1), complex(2, 1), complex(inf, -inf)}, + Test{complex(inf, 1), complex(2, -1), complex(inf, inf)}, + Test{complex(inf, 1), complex(2, 2), complex(inf, -inf)}, + Test{complex(inf, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, 1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, 1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, 1), complex(nan, 0), complex(nan, nan)}, + Test{complex(inf, 1), complex(nan, 1), complex(nan, nan)}, + Test{complex(inf, 1), complex(nan, -1), complex(nan, nan)}, + Test{complex(inf, 1), complex(nan, 2), complex(nan, nan)}, + Test{complex(inf, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, 1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, 1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, 1), complex(inf, 0), complex(-nan, -nan)}, + Test{complex(inf, 1), complex(inf, 1), complex(-nan, -nan)}, + Test{complex(inf, 1), complex(inf, -1), complex(-nan, -nan)}, + Test{complex(inf, 1), complex(inf, 2), complex(-nan, -nan)}, + Test{complex(inf, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, 1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, 1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, 1), complex(-inf, 0), complex(-nan, -nan)}, + Test{complex(inf, 1), complex(-inf, 1), complex(-nan, -nan)}, + Test{complex(inf, 1), complex(-inf, -1), complex(-nan, -nan)}, + Test{complex(inf, 1), complex(-inf, 2), complex(-nan, -nan)}, + Test{complex(inf, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, 1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, 1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, -1), complex(0, 0), complex(inf, -inf)}, + Test{complex(inf, -1), complex(0, 1), complex(-nan, -inf)}, + Test{complex(inf, -1), complex(0, -1), complex(-nan, inf)}, + Test{complex(inf, -1), complex(0, 2), complex(-nan, -inf)}, + Test{complex(inf, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, -1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, -1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, -1), complex(1, 0), complex(inf, -nan)}, + Test{complex(inf, -1), complex(1, 1), complex(inf, -inf)}, + Test{complex(inf, -1), complex(1, -1), complex(inf, inf)}, + Test{complex(inf, -1), complex(1, 2), complex(inf, -inf)}, + Test{complex(inf, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, -1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, -1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, -1), complex(-1, 0), complex(-inf, -nan)}, + Test{complex(inf, -1), complex(-1, 1), complex(-inf, -inf)}, + Test{complex(inf, -1), complex(-1, -1), complex(-inf, inf)}, + Test{complex(inf, -1), complex(-1, 2), complex(-inf, -inf)}, + Test{complex(inf, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, -1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, -1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, -1), complex(2, 0), complex(inf, -nan)}, + Test{complex(inf, -1), complex(2, 1), complex(inf, -inf)}, + Test{complex(inf, -1), complex(2, -1), complex(inf, inf)}, + Test{complex(inf, -1), complex(2, 2), complex(inf, -inf)}, + Test{complex(inf, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, -1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, -1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, -1), complex(nan, 0), complex(nan, nan)}, + Test{complex(inf, -1), complex(nan, 1), complex(nan, nan)}, + Test{complex(inf, -1), complex(nan, -1), complex(nan, nan)}, + Test{complex(inf, -1), complex(nan, 2), complex(nan, nan)}, + Test{complex(inf, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, -1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, -1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, -1), complex(inf, 0), complex(-nan, -nan)}, + Test{complex(inf, -1), complex(inf, 1), complex(-nan, -nan)}, + Test{complex(inf, -1), complex(inf, -1), complex(-nan, -nan)}, + Test{complex(inf, -1), complex(inf, 2), complex(-nan, -nan)}, + Test{complex(inf, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, -1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, -1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, -1), complex(-inf, 0), complex(-nan, -nan)}, + Test{complex(inf, -1), complex(-inf, 1), complex(-nan, -nan)}, + Test{complex(inf, -1), complex(-inf, -1), complex(-nan, -nan)}, + Test{complex(inf, -1), complex(-inf, 2), complex(-nan, -nan)}, + Test{complex(inf, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, -1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, -1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, 2), complex(0, 0), complex(inf, inf)}, + Test{complex(inf, 2), complex(0, 1), complex(-nan, -inf)}, + Test{complex(inf, 2), complex(0, -1), complex(-nan, inf)}, + Test{complex(inf, 2), complex(0, 2), complex(-nan, -inf)}, + Test{complex(inf, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, 2), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, 2), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, 2), complex(1, 0), complex(inf, -nan)}, + Test{complex(inf, 2), complex(1, 1), complex(inf, -inf)}, + Test{complex(inf, 2), complex(1, -1), complex(inf, inf)}, + Test{complex(inf, 2), complex(1, 2), complex(inf, -inf)}, + Test{complex(inf, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, 2), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, 2), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, 2), complex(-1, 0), complex(-inf, -nan)}, + Test{complex(inf, 2), complex(-1, 1), complex(-inf, -inf)}, + Test{complex(inf, 2), complex(-1, -1), complex(-inf, inf)}, + Test{complex(inf, 2), complex(-1, 2), complex(-inf, -inf)}, + Test{complex(inf, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, 2), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, 2), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, 2), complex(2, 0), complex(inf, -nan)}, + Test{complex(inf, 2), complex(2, 1), complex(inf, -inf)}, + Test{complex(inf, 2), complex(2, -1), complex(inf, inf)}, + Test{complex(inf, 2), complex(2, 2), complex(inf, -inf)}, + Test{complex(inf, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, 2), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, 2), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, 2), complex(nan, 0), complex(nan, nan)}, + Test{complex(inf, 2), complex(nan, 1), complex(nan, nan)}, + Test{complex(inf, 2), complex(nan, -1), complex(nan, nan)}, + Test{complex(inf, 2), complex(nan, 2), complex(nan, nan)}, + Test{complex(inf, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, 2), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, 2), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, 2), complex(inf, 0), complex(-nan, -nan)}, + Test{complex(inf, 2), complex(inf, 1), complex(-nan, -nan)}, + Test{complex(inf, 2), complex(inf, -1), complex(-nan, -nan)}, + Test{complex(inf, 2), complex(inf, 2), complex(-nan, -nan)}, + Test{complex(inf, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, 2), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, 2), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, 2), complex(-inf, 0), complex(-nan, -nan)}, + Test{complex(inf, 2), complex(-inf, 1), complex(-nan, -nan)}, + Test{complex(inf, 2), complex(-inf, -1), complex(-nan, -nan)}, + Test{complex(inf, 2), complex(-inf, 2), complex(-nan, -nan)}, + Test{complex(inf, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, 2), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, 2), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, nan), complex(0, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(0, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(0, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(0, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(-nan, inf), complex(0, 0), complex(-nan, inf)}, + Test{complex(-nan, inf), complex(0, 1), complex(inf, -nan)}, + Test{complex(-nan, inf), complex(0, -1), complex(-inf, -nan)}, + Test{complex(-nan, inf), complex(0, 2), complex(inf, -nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(1, 0), complex(-nan, inf)}, + Test{complex(-nan, inf), complex(1, 1), complex(inf, inf)}, + Test{complex(-nan, inf), complex(1, -1), complex(-inf, inf)}, + Test{complex(-nan, inf), complex(1, 2), complex(inf, inf)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-1, 0), complex(-nan, -inf)}, + Test{complex(-nan, inf), complex(-1, 1), complex(inf, -inf)}, + Test{complex(-nan, inf), complex(-1, -1), complex(-inf, -inf)}, + Test{complex(-nan, inf), complex(-1, 2), complex(inf, -inf)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(2, 0), complex(-nan, inf)}, + Test{complex(-nan, inf), complex(2, 1), complex(inf, inf)}, + Test{complex(-nan, inf), complex(2, -1), complex(-inf, inf)}, + Test{complex(-nan, inf), complex(2, 2), complex(inf, inf)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(nan, 0), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, 1), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, -1), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, 2), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(0, 0), complex(-nan, -inf)}, + Test{complex(-nan, -inf), complex(0, 1), complex(-inf, -nan)}, + Test{complex(-nan, -inf), complex(0, -1), complex(inf, -nan)}, + Test{complex(-nan, -inf), complex(0, 2), complex(-inf, -nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(1, 0), complex(-nan, -inf)}, + Test{complex(-nan, -inf), complex(1, 1), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(1, -1), complex(inf, -inf)}, + Test{complex(-nan, -inf), complex(1, 2), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-1, 0), complex(-nan, inf)}, + Test{complex(-nan, -inf), complex(-1, 1), complex(-inf, inf)}, + Test{complex(-nan, -inf), complex(-1, -1), complex(inf, inf)}, + Test{complex(-nan, -inf), complex(-1, 2), complex(-inf, inf)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(2, 0), complex(-nan, -inf)}, + Test{complex(-nan, -inf), complex(2, 1), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(2, -1), complex(inf, -inf)}, + Test{complex(-nan, -inf), complex(2, 2), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(nan, 0), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, 1), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, -1), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, 2), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, 0), complex(0, 0), complex(-inf, -nan)}, + Test{complex(-inf, 0), complex(0, 1), complex(-nan, inf)}, + Test{complex(-inf, 0), complex(0, -1), complex(-nan, -inf)}, + Test{complex(-inf, 0), complex(0, 2), complex(-nan, inf)}, + Test{complex(-inf, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, 0), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, 0), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, 0), complex(1, 0), complex(-inf, -nan)}, + Test{complex(-inf, 0), complex(1, 1), complex(-inf, inf)}, + Test{complex(-inf, 0), complex(1, -1), complex(-inf, -inf)}, + Test{complex(-inf, 0), complex(1, 2), complex(-inf, inf)}, + Test{complex(-inf, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, 0), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, 0), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, 0), complex(-1, 0), complex(inf, -nan)}, + Test{complex(-inf, 0), complex(-1, 1), complex(inf, inf)}, + Test{complex(-inf, 0), complex(-1, -1), complex(inf, -inf)}, + Test{complex(-inf, 0), complex(-1, 2), complex(inf, inf)}, + Test{complex(-inf, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, 0), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, 0), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, 0), complex(2, 0), complex(-inf, -nan)}, + Test{complex(-inf, 0), complex(2, 1), complex(-inf, inf)}, + Test{complex(-inf, 0), complex(2, -1), complex(-inf, -inf)}, + Test{complex(-inf, 0), complex(2, 2), complex(-inf, inf)}, + Test{complex(-inf, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, 0), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, 0), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, 0), complex(nan, 0), complex(nan, nan)}, + Test{complex(-inf, 0), complex(nan, 1), complex(nan, nan)}, + Test{complex(-inf, 0), complex(nan, -1), complex(nan, nan)}, + Test{complex(-inf, 0), complex(nan, 2), complex(nan, nan)}, + Test{complex(-inf, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, 0), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, 0), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, 0), complex(inf, 0), complex(-nan, -nan)}, + Test{complex(-inf, 0), complex(inf, 1), complex(-nan, -nan)}, + Test{complex(-inf, 0), complex(inf, -1), complex(-nan, -nan)}, + Test{complex(-inf, 0), complex(inf, 2), complex(-nan, -nan)}, + Test{complex(-inf, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, 0), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, 0), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, 0), complex(-inf, 0), complex(-nan, -nan)}, + Test{complex(-inf, 0), complex(-inf, 1), complex(-nan, -nan)}, + Test{complex(-inf, 0), complex(-inf, -1), complex(-nan, -nan)}, + Test{complex(-inf, 0), complex(-inf, 2), complex(-nan, -nan)}, + Test{complex(-inf, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, 0), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, 0), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, 1), complex(0, 0), complex(-inf, inf)}, + Test{complex(-inf, 1), complex(0, 1), complex(-nan, inf)}, + Test{complex(-inf, 1), complex(0, -1), complex(-nan, -inf)}, + Test{complex(-inf, 1), complex(0, 2), complex(-nan, inf)}, + Test{complex(-inf, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, 1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, 1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, 1), complex(1, 0), complex(-inf, -nan)}, + Test{complex(-inf, 1), complex(1, 1), complex(-inf, inf)}, + Test{complex(-inf, 1), complex(1, -1), complex(-inf, -inf)}, + Test{complex(-inf, 1), complex(1, 2), complex(-inf, inf)}, + Test{complex(-inf, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, 1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, 1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, 1), complex(-1, 0), complex(inf, -nan)}, + Test{complex(-inf, 1), complex(-1, 1), complex(inf, inf)}, + Test{complex(-inf, 1), complex(-1, -1), complex(inf, -inf)}, + Test{complex(-inf, 1), complex(-1, 2), complex(inf, inf)}, + Test{complex(-inf, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, 1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, 1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, 1), complex(2, 0), complex(-inf, -nan)}, + Test{complex(-inf, 1), complex(2, 1), complex(-inf, inf)}, + Test{complex(-inf, 1), complex(2, -1), complex(-inf, -inf)}, + Test{complex(-inf, 1), complex(2, 2), complex(-inf, inf)}, + Test{complex(-inf, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, 1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, 1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, 1), complex(nan, 0), complex(nan, nan)}, + Test{complex(-inf, 1), complex(nan, 1), complex(nan, nan)}, + Test{complex(-inf, 1), complex(nan, -1), complex(nan, nan)}, + Test{complex(-inf, 1), complex(nan, 2), complex(nan, nan)}, + Test{complex(-inf, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, 1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, 1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, 1), complex(inf, 0), complex(-nan, -nan)}, + Test{complex(-inf, 1), complex(inf, 1), complex(-nan, -nan)}, + Test{complex(-inf, 1), complex(inf, -1), complex(-nan, -nan)}, + Test{complex(-inf, 1), complex(inf, 2), complex(-nan, -nan)}, + Test{complex(-inf, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, 1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, 1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, 1), complex(-inf, 0), complex(-nan, -nan)}, + Test{complex(-inf, 1), complex(-inf, 1), complex(-nan, -nan)}, + Test{complex(-inf, 1), complex(-inf, -1), complex(-nan, -nan)}, + Test{complex(-inf, 1), complex(-inf, 2), complex(-nan, -nan)}, + Test{complex(-inf, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, 1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, 1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, -1), complex(0, 0), complex(-inf, -inf)}, + Test{complex(-inf, -1), complex(0, 1), complex(-nan, inf)}, + Test{complex(-inf, -1), complex(0, -1), complex(-nan, -inf)}, + Test{complex(-inf, -1), complex(0, 2), complex(-nan, inf)}, + Test{complex(-inf, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, -1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, -1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, -1), complex(1, 0), complex(-inf, -nan)}, + Test{complex(-inf, -1), complex(1, 1), complex(-inf, inf)}, + Test{complex(-inf, -1), complex(1, -1), complex(-inf, -inf)}, + Test{complex(-inf, -1), complex(1, 2), complex(-inf, inf)}, + Test{complex(-inf, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, -1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, -1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, -1), complex(-1, 0), complex(inf, -nan)}, + Test{complex(-inf, -1), complex(-1, 1), complex(inf, inf)}, + Test{complex(-inf, -1), complex(-1, -1), complex(inf, -inf)}, + Test{complex(-inf, -1), complex(-1, 2), complex(inf, inf)}, + Test{complex(-inf, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, -1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, -1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, -1), complex(2, 0), complex(-inf, -nan)}, + Test{complex(-inf, -1), complex(2, 1), complex(-inf, inf)}, + Test{complex(-inf, -1), complex(2, -1), complex(-inf, -inf)}, + Test{complex(-inf, -1), complex(2, 2), complex(-inf, inf)}, + Test{complex(-inf, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, -1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, -1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, -1), complex(nan, 0), complex(nan, nan)}, + Test{complex(-inf, -1), complex(nan, 1), complex(nan, nan)}, + Test{complex(-inf, -1), complex(nan, -1), complex(nan, nan)}, + Test{complex(-inf, -1), complex(nan, 2), complex(nan, nan)}, + Test{complex(-inf, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, -1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, -1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, -1), complex(inf, 0), complex(-nan, -nan)}, + Test{complex(-inf, -1), complex(inf, 1), complex(-nan, -nan)}, + Test{complex(-inf, -1), complex(inf, -1), complex(-nan, -nan)}, + Test{complex(-inf, -1), complex(inf, 2), complex(-nan, -nan)}, + Test{complex(-inf, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, -1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, -1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, -1), complex(-inf, 0), complex(-nan, -nan)}, + Test{complex(-inf, -1), complex(-inf, 1), complex(-nan, -nan)}, + Test{complex(-inf, -1), complex(-inf, -1), complex(-nan, -nan)}, + Test{complex(-inf, -1), complex(-inf, 2), complex(-nan, -nan)}, + Test{complex(-inf, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, -1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, -1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, 2), complex(0, 0), complex(-inf, inf)}, + Test{complex(-inf, 2), complex(0, 1), complex(-nan, inf)}, + Test{complex(-inf, 2), complex(0, -1), complex(-nan, -inf)}, + Test{complex(-inf, 2), complex(0, 2), complex(-nan, inf)}, + Test{complex(-inf, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, 2), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, 2), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, 2), complex(1, 0), complex(-inf, -nan)}, + Test{complex(-inf, 2), complex(1, 1), complex(-inf, inf)}, + Test{complex(-inf, 2), complex(1, -1), complex(-inf, -inf)}, + Test{complex(-inf, 2), complex(1, 2), complex(-inf, inf)}, + Test{complex(-inf, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, 2), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, 2), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, 2), complex(-1, 0), complex(inf, -nan)}, + Test{complex(-inf, 2), complex(-1, 1), complex(inf, inf)}, + Test{complex(-inf, 2), complex(-1, -1), complex(inf, -inf)}, + Test{complex(-inf, 2), complex(-1, 2), complex(inf, inf)}, + Test{complex(-inf, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, 2), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, 2), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, 2), complex(2, 0), complex(-inf, -nan)}, + Test{complex(-inf, 2), complex(2, 1), complex(-inf, inf)}, + Test{complex(-inf, 2), complex(2, -1), complex(-inf, -inf)}, + Test{complex(-inf, 2), complex(2, 2), complex(-inf, inf)}, + Test{complex(-inf, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, 2), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, 2), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, 2), complex(nan, 0), complex(nan, nan)}, + Test{complex(-inf, 2), complex(nan, 1), complex(nan, nan)}, + Test{complex(-inf, 2), complex(nan, -1), complex(nan, nan)}, + Test{complex(-inf, 2), complex(nan, 2), complex(nan, nan)}, + Test{complex(-inf, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, 2), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, 2), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, 2), complex(inf, 0), complex(-nan, -nan)}, + Test{complex(-inf, 2), complex(inf, 1), complex(-nan, -nan)}, + Test{complex(-inf, 2), complex(inf, -1), complex(-nan, -nan)}, + Test{complex(-inf, 2), complex(inf, 2), complex(-nan, -nan)}, + Test{complex(-inf, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, 2), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, 2), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, 2), complex(-inf, 0), complex(-nan, -nan)}, + Test{complex(-inf, 2), complex(-inf, 1), complex(-nan, -nan)}, + Test{complex(-inf, 2), complex(-inf, -1), complex(-nan, -nan)}, + Test{complex(-inf, 2), complex(-inf, 2), complex(-nan, -nan)}, + Test{complex(-inf, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, 2), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, 2), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, nan), complex(0, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(0, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(0, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(0, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(-nan, inf), complex(0, 0), complex(-nan, inf)}, + Test{complex(-nan, inf), complex(0, 1), complex(inf, -nan)}, + Test{complex(-nan, inf), complex(0, -1), complex(-inf, -nan)}, + Test{complex(-nan, inf), complex(0, 2), complex(inf, -nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(1, 0), complex(-nan, inf)}, + Test{complex(-nan, inf), complex(1, 1), complex(inf, inf)}, + Test{complex(-nan, inf), complex(1, -1), complex(-inf, inf)}, + Test{complex(-nan, inf), complex(1, 2), complex(inf, inf)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-1, 0), complex(-nan, -inf)}, + Test{complex(-nan, inf), complex(-1, 1), complex(inf, -inf)}, + Test{complex(-nan, inf), complex(-1, -1), complex(-inf, -inf)}, + Test{complex(-nan, inf), complex(-1, 2), complex(inf, -inf)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(2, 0), complex(-nan, inf)}, + Test{complex(-nan, inf), complex(2, 1), complex(inf, inf)}, + Test{complex(-nan, inf), complex(2, -1), complex(-inf, inf)}, + Test{complex(-nan, inf), complex(2, 2), complex(inf, inf)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(nan, 0), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, 1), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, -1), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, 2), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(0, 0), complex(-nan, -inf)}, + Test{complex(-nan, -inf), complex(0, 1), complex(-inf, -nan)}, + Test{complex(-nan, -inf), complex(0, -1), complex(inf, -nan)}, + Test{complex(-nan, -inf), complex(0, 2), complex(-inf, -nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(1, 0), complex(-nan, -inf)}, + Test{complex(-nan, -inf), complex(1, 1), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(1, -1), complex(inf, -inf)}, + Test{complex(-nan, -inf), complex(1, 2), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-1, 0), complex(-nan, inf)}, + Test{complex(-nan, -inf), complex(-1, 1), complex(-inf, inf)}, + Test{complex(-nan, -inf), complex(-1, -1), complex(inf, inf)}, + Test{complex(-nan, -inf), complex(-1, 2), complex(-inf, inf)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(2, 0), complex(-nan, -inf)}, + Test{complex(-nan, -inf), complex(2, 1), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(2, -1), complex(inf, -inf)}, + Test{complex(-nan, -inf), complex(2, 2), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(nan, 0), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, 1), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, -1), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, 2), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, } diff --git a/test/complit.go b/test/complit.go index f3b7c9abe..f5f7aca9d 100644 --- a/test/complit.go +++ b/test/complit.go @@ -6,9 +6,16 @@ package main -type T struct { i int; f float; s string; next *T } +type T struct { + i int + f float64 + s string + next *T +} -type R struct { num int } +type R struct { + num int +} func itor(a int) *R { r := new(R) @@ -18,11 +25,16 @@ func itor(a int) *R { func eq(a []*R) { for i := 0; i < len(a); i++ { - if a[i].num != i { panic("bad") } + if a[i].num != i { + panic("bad") + } } } -type P struct { a, b int } +type P struct { + a, b int +} + func NewP(a, b int) *P { return &P{a, b} } @@ -34,37 +46,57 @@ func main() { var tp *T tp = &T{0, 7.2, "hi", &t} - a1 := []int{1,2,3} - if len(a1) != 3 { panic("a1") } - a2 := [10]int{1,2,3} - if len(a2) != 10 || cap(a2) != 10 { panic("a2") } + a1 := []int{1, 2, 3} + if len(a1) != 3 { + panic("a1") + } + a2 := [10]int{1, 2, 3} + if len(a2) != 10 || cap(a2) != 10 { + panic("a2") + } - a3 := [10]int{1,2,3,} - if len(a3) != 10 || a2[3] != 0 { panic("a3") } + a3 := [10]int{1, 2, 3} + if len(a3) != 10 || a2[3] != 0 { + panic("a3") + } var oai []int - oai = []int{1,2,3} - if len(oai) != 3 { panic("oai") } + oai = []int{1, 2, 3} + if len(oai) != 3 { + panic("oai") + } at := [...]*T{&t, tp, &t} - if len(at) != 3 { panic("at") } + if len(at) != 3 { + panic("at") + } c := make(chan int) ac := []chan int{c, c, c} - if len(ac) != 3 { panic("ac") } + if len(ac) != 3 { + panic("ac") + } aat := [][len(at)]*T{at, at} - if len(aat) != 2 || len(aat[1]) != 3 { panic("aat") } + if len(aat) != 2 || len(aat[1]) != 3 { + panic("aat") + } s := string([]byte{'h', 'e', 'l', 'l', 'o'}) - if s != "hello" { panic("s") } + if s != "hello" { + panic("s") + } - m := map[string]float{"one":1.0, "two":2.0, "pi":22./7.} - if len(m) != 3 { panic("m") } + m := map[string]float64{"one": 1.0, "two": 2.0, "pi": 22. / 7.} + if len(m) != 3 { + panic("m") + } eq([]*R{itor(0), itor(1), itor(2), itor(3), itor(4), itor(5)}) p1 := NewP(1, 2) p2 := NewP(1, 2) - if p1 == p2 { panic("NewP") } + if p1 == p2 { + panic("NewP") + } } diff --git a/test/const1.go b/test/const1.go index cf07055cf..67f36e4fd 100644 --- a/test/const1.go +++ b/test/const1.go @@ -6,76 +6,77 @@ package main -type I interface {} +type I interface{} + const ( // assume all types behave similarly to int8/uint8 - Int8 int8 = 101 - Minus1 int8 = -1 - Uint8 uint8 = 102 - Const = 103 + Int8 int8 = 101 + Minus1 int8 = -1 + Uint8 uint8 = 102 + Const = 103 - Float32 float32 = 104.5 - Float float = 105.5 + Float32 float32 = 104.5 + Float64 float64 = 105.5 ConstFloat = 106.5 - Big float64 = 1e300 + Big float64 = 1e300 String = "abc" - Bool = true + Bool = true ) var ( - a1 = Int8 * 100 // ERROR "overflow" - a2 = Int8 * -1 // OK - a3 = Int8 * 1000 // ERROR "overflow" - a4 = Int8 * int8(1000) // ERROR "overflow" - a5 = int8(Int8 * 1000) // ERROR "overflow" - a6 = int8(Int8 * int8(1000)) // ERROR "overflow" - a7 = Int8 - 2*Int8 - 2*Int8 // ERROR "overflow" - a8 = Int8 * Const / 100 // ERROR "overflow" - a9 = Int8 * (Const / 100) // OK + a1 = Int8 * 100 // ERROR "overflow" + a2 = Int8 * -1 // OK + a3 = Int8 * 1000 // ERROR "overflow" + a4 = Int8 * int8(1000) // ERROR "overflow" + a5 = int8(Int8 * 1000) // ERROR "overflow" + a6 = int8(Int8 * int8(1000)) // ERROR "overflow" + a7 = Int8 - 2*Int8 - 2*Int8 // ERROR "overflow" + a8 = Int8 * Const / 100 // ERROR "overflow" + a9 = Int8 * (Const / 100) // OK - b1 = Uint8 * Uint8 // ERROR "overflow" - b2 = Uint8 * -1 // ERROR "overflow" - b3 = Uint8 - Uint8 // OK - b4 = Uint8 - Uint8 - Uint8 // ERROR "overflow" - b5 = uint8(^0) // ERROR "overflow" - b6 = ^uint8(0) // OK - b7 = uint8(Minus1) // ERROR "overflow" - b8 = uint8(int8(-1)) // ERROR "overflow" - b8a = uint8(-1) // ERROR "overflow" - b9 byte = (1<<10) >> 8 // OK - b10 byte = (1<<10) // ERROR "overflow" - b11 byte = (byte(1)<<10) >> 8 // ERROR "overflow" - b12 byte = 1000 // ERROR "overflow" - b13 byte = byte(1000) // ERROR "overflow" - b14 byte = byte(100) * byte(100) // ERROR "overflow" - b15 byte = byte(100) * 100 // ERROR "overflow" - b16 byte = byte(0) * 1000 // ERROR "overflow" - b16a byte = 0 * 1000 // OK - b17 byte = byte(0) * byte(1000) // ERROR "overflow" - b18 byte = Uint8/0 // ERROR "division by zero" + b1 = Uint8 * Uint8 // ERROR "overflow" + b2 = Uint8 * -1 // ERROR "overflow" + b3 = Uint8 - Uint8 // OK + b4 = Uint8 - Uint8 - Uint8 // ERROR "overflow" + b5 = uint8(^0) // ERROR "overflow" + b6 = ^uint8(0) // OK + b7 = uint8(Minus1) // ERROR "overflow" + b8 = uint8(int8(-1)) // ERROR "overflow" + b8a = uint8(-1) // ERROR "overflow" + b9 byte = (1 << 10) >> 8 // OK + b10 byte = (1 << 10) // ERROR "overflow" + b11 byte = (byte(1) << 10) >> 8 // ERROR "overflow" + b12 byte = 1000 // ERROR "overflow" + b13 byte = byte(1000) // ERROR "overflow" + b14 byte = byte(100) * byte(100) // ERROR "overflow" + b15 byte = byte(100) * 100 // ERROR "overflow" + b16 byte = byte(0) * 1000 // ERROR "overflow" + b16a byte = 0 * 1000 // OK + b17 byte = byte(0) * byte(1000) // ERROR "overflow" + b18 byte = Uint8 / 0 // ERROR "division by zero" - c1 float64 = Big - c2 float64 = Big*Big // ERROR "overflow" - c3 float64 = float64(Big)*Big // ERROR "overflow" - c4 = Big*Big // ERROR "overflow" - c5 = Big/0 // ERROR "division by zero" + c1 float64 = Big + c2 float64 = Big * Big // ERROR "overflow" + c3 float64 = float64(Big) * Big // ERROR "overflow" + c4 = Big * Big // ERROR "overflow" + c5 = Big / 0 // ERROR "division by zero" ) func f(int) func main() { - f(Int8) // ERROR "convert|wrong type|cannot" - f(Minus1) // ERROR "convert|wrong type|cannot" - f(Uint8) // ERROR "convert|wrong type|cannot" - f(Const) // OK - f(Float32) // ERROR "convert|wrong type|cannot" - f(Float) // ERROR "convert|wrong type|cannot" - f(ConstFloat) // ERROR "truncate" - f(ConstFloat - 0.5) // OK - f(Big) // ERROR "convert|wrong type|cannot" - f(String) // ERROR "convert|wrong type|cannot|incompatible" - f(Bool) // ERROR "convert|wrong type|cannot|incompatible" + f(Int8) // ERROR "convert|wrong type|cannot" + f(Minus1) // ERROR "convert|wrong type|cannot" + f(Uint8) // ERROR "convert|wrong type|cannot" + f(Const) // OK + f(Float32) // ERROR "convert|wrong type|cannot" + f(Float64) // ERROR "convert|wrong type|cannot" + f(ConstFloat) // ERROR "truncate" + f(ConstFloat - 0.5) // OK + f(Big) // ERROR "convert|wrong type|cannot" + f(String) // ERROR "convert|wrong type|cannot|incompatible" + f(Bool) // ERROR "convert|wrong type|cannot|incompatible" } -const ptr = nil // ERROR "const.*nil" +const ptr = nil // ERROR "const.*nil" diff --git a/test/convlit.go b/test/convlit.go index 94889d4a9..90ac5490c 100644 --- a/test/convlit.go +++ b/test/convlit.go @@ -11,54 +11,56 @@ package main // the language spec says for now. var x1 = string(1) var x2 string = string(1) -var x3 = int(1.5) // ERROR "convert|truncate" -var x4 int = int(1.5) // ERROR "convert|truncate" +var x3 = int(1.5) // ERROR "convert|truncate" +var x4 int = int(1.5) // ERROR "convert|truncate" var x5 = "a" + string(1) -var x6 = int(1e100) // ERROR "overflow" -var x7 = float(1e1000) // ERROR "overflow" +var x6 = int(1e100) // ERROR "overflow" +var x7 = float32(1e1000) // ERROR "overflow" // implicit conversions merit scrutiny var s string -var bad1 string = 1 // ERROR "conver|incompatible|invalid|cannot" -var bad2 = s + 1 // ERROR "conver|incompatible|invalid" -var bad3 = s + 'a' // ERROR "conver|incompatible|invalid" -var bad4 = "a" + 1 // ERROR "literals|incompatible|convert|invalid" -var bad5 = "a" + 'a' // ERROR "literals|incompatible|convert|invalid" +var bad1 string = 1 // ERROR "conver|incompatible|invalid|cannot" +var bad2 = s + 1 // ERROR "conver|incompatible|invalid" +var bad3 = s + 'a' // ERROR "conver|incompatible|invalid" +var bad4 = "a" + 1 // ERROR "literals|incompatible|convert|invalid" +var bad5 = "a" + 'a' // ERROR "literals|incompatible|convert|invalid" -var bad6 int = 1.5 // ERROR "convert|truncate" -var bad7 int = 1e100 // ERROR "overflow" -var bad8 float32 = 1e200 // ERROR "overflow" +var bad6 int = 1.5 // ERROR "convert|truncate" +var bad7 int = 1e100 // ERROR "overflow" +var bad8 float32 = 1e200 // ERROR "overflow" // but these implicit conversions are okay var good1 string = "a" var good2 int = 1.0 var good3 int = 1e9 -var good4 float = 1e20 +var good4 float64 = 1e20 // explicit conversion of string is okay var _ = []int("abc") var _ = []byte("abc") // implicit is not -var _ []int = "abc" // ERROR "cannot use|incompatible|invalid" -var _ []byte = "abc" // ERROR "cannot use|incompatible|invalid" +var _ []int = "abc" // ERROR "cannot use|incompatible|invalid" +var _ []byte = "abc" // ERROR "cannot use|incompatible|invalid" // named string is okay type Tstring string + var ss Tstring = "abc" var _ = []int(ss) var _ = []byte(ss) // implicit is still not -var _ []int = ss // ERROR "cannot use|incompatible|invalid" -var _ []byte = ss // ERROR "cannot use|incompatible|invalid" +var _ []int = ss // ERROR "cannot use|incompatible|invalid" +var _ []byte = ss // ERROR "cannot use|incompatible|invalid" // named slice is not type Tint []int type Tbyte []byte -var _ = Tint("abc") // ERROR "convert|incompatible|invalid" -var _ = Tbyte("abc") // ERROR "convert|incompatible|invalid" + +var _ = Tint("abc") // ERROR "convert|incompatible|invalid" +var _ = Tbyte("abc") // ERROR "convert|incompatible|invalid" // implicit is still not -var _ Tint = "abc" // ERROR "cannot use|incompatible|invalid" -var _ Tbyte = "abc" // ERROR "cannot use|incompatible|invalid" +var _ Tint = "abc" // ERROR "cannot use|incompatible|invalid" +var _ Tbyte = "abc" // ERROR "cannot use|incompatible|invalid" diff --git a/test/decl.go b/test/decl.go index c31082bcf..95b6346c3 100644 --- a/test/decl.go +++ b/test/decl.go @@ -8,26 +8,26 @@ package main -func f1() int { return 1 } -func f2() (float, int) { return 1, 2 } -func f3() (float, int, string) { return 1, 2, "3" } +func f1() int { return 1 } +func f2() (float32, int) { return 1, 2 } +func f3() (float32, int, string) { return 1, 2, "3" } func x() (s string) { a, b, s := f3() _, _ = a, b - return // tests that result var is in scope for redeclaration + return // tests that result var is in scope for redeclaration } func main() { i, f, s := f3() - j, f := f2() // redeclare f + j, f := f2() // redeclare f k := f1() m, g, s := f3() m, h, s := f3() { // new block should be ok. i, f, s := f3() - j, f := f2() // redeclare f + j, f := f2() // redeclare f k := f1() m, g, s := f3() m, h, s := f3() diff --git a/test/declbad.go b/test/declbad.go index 269ebdefb..5e5e14501 100644 --- a/test/declbad.go +++ b/test/declbad.go @@ -8,51 +8,51 @@ package main -func f1() int { return 1 } -func f2() (float, int) { return 1, 2 } -func f3() (float, int, string) { return 1, 2, "3" } +func f1() int { return 1 } +func f2() (float32, int) { return 1, 2 } +func f3() (float32, int, string) { return 1, 2, "3" } func main() { { // simple redeclaration i := f1() - i := f1() // ERROR "redeclared|no new" + i := f1() // ERROR "redeclared|no new" _ = i } { // change of type for f i, f, s := f3() - f, g, t := f3() // ERROR "redeclared|cannot assign|incompatible" + f, g, t := f3() // ERROR "redeclared|cannot assign|incompatible" _, _, _, _, _ = i, f, s, g, t } { // change of type for i i, f, s := f3() - j, i, t := f3() // ERROR "redeclared|cannot assign|incompatible" + j, i, t := f3() // ERROR "redeclared|cannot assign|incompatible" _, _, _, _, _ = i, f, s, j, t } { // no new variables i, f, s := f3() - i, f := f2() // ERROR "redeclared|no new" + i, f := f2() // ERROR "redeclared|no new" _, _, _ = i, f, s } { // single redeclaration i, f, s := f3() - i := f1() // ERROR "redeclared|no new|incompatible" + i := f1() // ERROR "redeclared|no new|incompatible" _, _, _ = i, f, s } - // double redeclaration + // double redeclaration { i, f, s := f3() - i, f := f2() // ERROR "redeclared|no new" + i, f := f2() // ERROR "redeclared|no new" _, _, _ = i, f, s } { // triple redeclaration i, f, s := f3() - i, f, s := f3() // ERROR "redeclared|no new" + i, f, s := f3() // ERROR "redeclared|no new" _, _, _ = i, f, s } } diff --git a/test/errchk b/test/errchk index b0edd7a6b..fbb021ce4 100755 --- a/test/errchk +++ b/test/errchk @@ -73,6 +73,7 @@ sub chk { my @match; foreach my $src (@{$src{$file}}) { $line++; + next if $src =~ m|////|; # double comment disables ERROR next unless $src =~ m|// (GC_)?ERROR (.*)|; $regexp = $2; if($regexp !~ /^"([^"]*)"/) { diff --git a/test/fixedbugs/bug006.go b/test/fixedbugs/bug006.go index e7694f95b..43b5dfb12 100644 --- a/test/fixedbugs/bug006.go +++ b/test/fixedbugs/bug006.go @@ -9,11 +9,16 @@ package main import "os" const ( - x float = iota; - g float = 4.5 * iota; -); + x float64 = iota + g float64 = 4.5 * iota +) func main() { - if g == 0.0 { print("zero\n");} - if g != 4.5 { print(" fail\n"); os.Exit(1); } + if g == 0.0 { + print("zero\n") + } + if g != 4.5 { + print(" fail\n") + os.Exit(1) + } } diff --git a/test/fixedbugs/bug007.go b/test/fixedbugs/bug007.go index bd970de5f..d65f6da45 100644 --- a/test/fixedbugs/bug007.go +++ b/test/fixedbugs/bug007.go @@ -7,7 +7,9 @@ package main type ( - Point struct { x, y float }; + Point struct { + x, y float64 + } Polar Point ) diff --git a/test/fixedbugs/bug010.go b/test/fixedbugs/bug010.go index e71c4d7f0..7d96988d4 100644 --- a/test/fixedbugs/bug010.go +++ b/test/fixedbugs/bug010.go @@ -7,14 +7,14 @@ package main -func f(i int, f float) { - i = 8; - f = 8.0; - return; +func f(i int, f float64) { + i = 8 + f = 8.0 + return } func main() { - f(3, float(5)) + f(3, float64(5)) } /* diff --git a/test/fixedbugs/bug011.go b/test/fixedbugs/bug011.go index 551adb77d..ce627472c 100644 --- a/test/fixedbugs/bug011.go +++ b/test/fixedbugs/bug011.go @@ -8,19 +8,19 @@ package main type T struct { - x, y int; + x, y int } -func (t *T) m(a int, b float) int { - return (t.x+a) * (t.y+int(b)); +func (t *T) m(a int, b float64) int { + return (t.x + a) * (t.y + int(b)) } func main() { - var t *T = new(T); - t.x = 1; - t.y = 2; - r10 := t.m(1, 3.0); - _ = r10; + var t *T = new(T) + t.x = 1 + t.y = 2 + r10 := t.m(1, 3.0) + _ = r10 } /* bug11.go:16: fatal error: walktype: switch 1 unknown op CALLMETH l(16) <int32>INT32 diff --git a/test/fixedbugs/bug016.go b/test/fixedbugs/bug016.go index 461bcf82a..1cdd8df08 100644 --- a/test/fixedbugs/bug016.go +++ b/test/fixedbugs/bug016.go @@ -1,4 +1,4 @@ -// ! $G $D/$F.go +// errchk $G -e $D/$F.go // Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style @@ -7,8 +7,8 @@ package main func main() { - var i int = 100; - i = i << -3; // BUG: should not compile (negative shift) + var i int = 100 + i = i << -3 // ERROR "overflows" } /* diff --git a/test/fixedbugs/bug035.go b/test/fixedbugs/bug035.go index 461c0607a..bd2a633f2 100644 --- a/test/fixedbugs/bug035.go +++ b/test/fixedbugs/bug035.go @@ -6,8 +6,8 @@ package main -func f9(a int) (i int, f float) { - i := 9; // ERROR "redecl|no new" - f := float(9); // ERROR "redecl|no new" - return i, f; +func f9(a int) (i int, f float64) { + i := 9 // ERROR "redecl|no new" + f := float64(9) // ERROR "redecl|no new" + return i, f } diff --git a/test/fixedbugs/bug047.go b/test/fixedbugs/bug047.go index f3749e739..5a776abce 100644 --- a/test/fixedbugs/bug047.go +++ b/test/fixedbugs/bug047.go @@ -9,15 +9,15 @@ package main func main() { type T struct { - s string; - f float; - }; - var s string = "hello"; - var f float = 0.2; - t := T{s, f}; + s string + f float64 + } + var s string = "hello" + var f float64 = 0.2 + t := T{s, f} - type M map[int] int; - m0 := M{7:8}; + type M map[int]int + m0 := M{7: 8} - _, _ = t, m0; + _, _ = t, m0 } diff --git a/test/fixedbugs/bug069.go b/test/fixedbugs/bug069.go index d6796cd72..bf7316313 100644 --- a/test/fixedbugs/bug069.go +++ b/test/fixedbugs/bug069.go @@ -6,15 +6,16 @@ package main -func main(){ - c := make(chan int); - ok := false; - var i int; - - i, ok = <-c; // works - _, _ = i, ok; - - ca := new([2]chan int); - i, ok = <-(ca[0]); // fails: c.go:11: bad shape across assignment - cr=1 cl=2 - _, _ = i, ok; +func main() { + //TODO(rsc): uncomment when this syntax is valid for receive+check closed + // c := make(chan int); + // ok := false; + // var i int; + // + // i, ok = <-c; // works + // _, _ = i, ok; + // + // ca := new([2]chan int); + // i, ok = <-(ca[0]); // fails: c.go:11: bad shape across assignment - cr=1 cl=2 + // _, _ = i, ok; } diff --git a/test/fixedbugs/bug080.go b/test/fixedbugs/bug080.go index a5003d29b..bae16cdb2 100644 --- a/test/fixedbugs/bug080.go +++ b/test/fixedbugs/bug080.go @@ -4,18 +4,18 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. -package main - -func f1() (x int, y float) { - return; +package main + +func f1() (x int, y float64) { + return } -func f2 (x int, y float) { - return; +func f2(x int, y float64) { + return } func main() { - f2(f1()); // this should be a legal call + f2(f1()) // this should be a legal call } /* diff --git a/test/fixedbugs/bug081.go b/test/fixedbugs/bug081.go index ccb369953..8d3d538c8 100644 --- a/test/fixedbugs/bug081.go +++ b/test/fixedbugs/bug081.go @@ -1,12 +1,12 @@ -// ! $G $D/$F.go +// errchk $G $D/$F.go // Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. -package main - -const x x = 2; +package main + +const x x = 2 // ERROR "loop" /* bug081.go:3: first constant must evaluate an expression diff --git a/test/fixedbugs/bug109.go b/test/fixedbugs/bug109.go index c679771f2..766657723 100644 --- a/test/fixedbugs/bug109.go +++ b/test/fixedbugs/bug109.go @@ -5,10 +5,11 @@ // license that can be found in the LICENSE file. package main -func f(a float) float { - e := 1.0; - e = e * a; - return e; + +func f(a float64) float64 { + e := 1.0 + e = e * a + return e } /* diff --git a/test/fixedbugs/bug167.go b/test/fixedbugs/bug167.go index 729299b66..33eb3cb1a 100644 --- a/test/fixedbugs/bug167.go +++ b/test/fixedbugs/bug167.go @@ -7,20 +7,24 @@ package main func f1() { - type T struct { x int } + type T struct { + x int + } } func f2() { - type T struct { x float } + type T struct { + x float64 + } } func main() { - f1(); - f2(); + f1() + f2() } /* 1606416576: conflicting definitions for main.T·bug167 bug167.6: type main.T·bug167 struct { x int } -bug167.6: type main.T·bug167 struct { x float } +bug167.6: type main.T·bug167 struct { x float64 } */ diff --git a/test/fixedbugs/bug193.go b/test/fixedbugs/bug193.go index f6b03e13d..5ef02b1c1 100644 --- a/test/fixedbugs/bug193.go +++ b/test/fixedbugs/bug193.go @@ -7,10 +7,10 @@ package main func main() { - s := uint(10); - ss := 1<<s; - y1 := float(ss); - y2 := float(1<<s); // ERROR "shift" - y3 := string(1<<s); // ERROR "shift" - _, _, _, _, _ = s, ss, y1, y2, y3; + s := uint(10) + ss := 1 << s + y1 := float64(ss) + y2 := float64(1 << s) // ERROR "shift" + y3 := string(1 << s) // ERROR "shift" + _, _, _, _, _ = s, ss, y1, y2, y3 } diff --git a/test/fixedbugs/bug196.go b/test/fixedbugs/bug196.go index ea8ab0dc1..8cb9c9990 100644 --- a/test/fixedbugs/bug196.go +++ b/test/fixedbugs/bug196.go @@ -13,11 +13,12 @@ var i int func multi() (int, int) { return 1, 2 } func xxx() { - var c chan int - x, ok := <-c + //TODO(rsc): uncomment when this syntax is valid for receive+check closed + // var c chan int + // x, ok := <-c var m map[int]int - x, ok = m[1] + x, ok := m[1] var i interface{} var xx int diff --git a/test/fixedbugs/bug220.go b/test/fixedbugs/bug220.go index 3f8aaa4ec..ff027ddc2 100644 --- a/test/fixedbugs/bug220.go +++ b/test/fixedbugs/bug220.go @@ -7,8 +7,8 @@ package main func main() { - m := make(map[int]map[uint]float); - - m[0] = make(map[uint]float), false; // 6g used to reject this - m[1] = nil; + m := make(map[int]map[uint]float64) + + m[0] = make(map[uint]float64), false // 6g used to reject this + m[1] = nil } diff --git a/test/fixedbugs/bug230.go b/test/fixedbugs/bug230.go index 81b256e31..c7ad1a366 100644 --- a/test/fixedbugs/bug230.go +++ b/test/fixedbugs/bug230.go @@ -8,14 +8,17 @@ package main type S string type I int -type F float +type F float64 func (S) m() {} func (I) m() {} func (F) m() {} func main() { - c := make(chan interface { m() }, 10) + c := make(chan interface { + m() + }, + 10) c <- I(0) c <- F(1) c <- S("hi") diff --git a/test/fixedbugs/bug234.go b/test/fixedbugs/bug234.go index b806ca64e..9affad043 100644 --- a/test/fixedbugs/bug234.go +++ b/test/fixedbugs/bug234.go @@ -7,16 +7,17 @@ package main func main() { - c := make(chan int, 1) - c <- 100 - x, ok := <-c - if x != 100 || !ok { - println("x=", x, " ok=", ok, " want 100, true") - panic("fail") - } - x, ok = <-c - if x != 0 || ok { - println("x=", x, " ok=", ok, " want 0, false") - panic("fail") - } + //TODO(rsc): uncomment when this syntax is valid for receive+check closed + // c := make(chan int, 1) + // c <- 100 + // x, ok := <-c + // if x != 100 || !ok { + // println("x=", x, " ok=", ok, " want 100, true") + // panic("fail") + // } + // x, ok = <-c + // if x != 0 || ok { + // println("x=", x, " ok=", ok, " want 0, false") + // panic("fail") + // } } diff --git a/test/fixedbugs/bug238.go b/test/fixedbugs/bug238.go index 8b7c7ac38..7e8660d37 100644 --- a/test/fixedbugs/bug238.go +++ b/test/fixedbugs/bug238.go @@ -17,6 +17,6 @@ const f struct{} = 6 // ERROR "convert|wrong|invalid" const g interface{} = 7 // ERROR "constant|wrong|invalid" const h bool = false const i int = 2 -const j float = 5 +const j float64 = 5 func main() { println(a, b, c, d, e, f, g) } diff --git a/test/fixedbugs/bug242.go b/test/fixedbugs/bug242.go index 5c21eaaf0..ad1cef8df 100644 --- a/test/fixedbugs/bug242.go +++ b/test/fixedbugs/bug242.go @@ -101,10 +101,13 @@ func main() { c := make(chan byte, 1) c <- 'C' + //TODO(rsc): uncomment when this syntax is valid for receive+check closed // 15 16 - *f(), p1 = <-e1(c, 16) + // *f(), p1 = <-e1(c, 16) + *f(), p1 = <-e1(c, 16), true // delete uncommenting above // 17 18 - *f(), p2 = <-e1(c, 18) + // *f(), p2 = <-e1(c, 18) + *f(), p2, _ = 0, false, e1(c, 18) // delete when uncommenting above a[17] += '0' if !p1 || p2 { println("bad chan check", i, p1, p2) diff --git a/test/fixedbugs/bug248.dir/bug2.go b/test/fixedbugs/bug248.dir/bug2.go index 68c0ce0bc..4ea187a4b 100644 --- a/test/fixedbugs/bug248.dir/bug2.go +++ b/test/fixedbugs/bug248.dir/bug2.go @@ -23,7 +23,7 @@ type t0 int func (t0) M(p0.T) {} -type t1 float +type t1 float64 func (t1) M(p1.T) {} diff --git a/test/fixedbugs/bug248.dir/bug3.go b/test/fixedbugs/bug248.dir/bug3.go index c96bf1676..e5a244955 100644 --- a/test/fixedbugs/bug248.dir/bug3.go +++ b/test/fixedbugs/bug248.dir/bug3.go @@ -26,7 +26,7 @@ type t0 int func (t0) M(p0.T) {} // t1 satisfies I1 and p1.I -type t1 float +type t1 float64 func (t1) M(p1.T) {} diff --git a/test/fixedbugs/bug299.go b/test/fixedbugs/bug299.go index 4d7314432..1c7adb5f5 100644 --- a/test/fixedbugs/bug299.go +++ b/test/fixedbugs/bug299.go @@ -11,9 +11,9 @@ type T struct { x int y (int) int - *float + *float64 // not legal according to spec - (complex) // ERROR "non-declaration|expected|parenthesize" + (complex128) // ERROR "non-declaration|expected|parenthesize" (*string) // ERROR "non-declaration|expected|parenthesize" *(bool) // ERROR "non-declaration|expected|parenthesize" } diff --git a/test/fixedbugs/bug307.go b/test/fixedbugs/bug307.go index a1a30dfb7..1b42c09ab 100644 --- a/test/fixedbugs/bug307.go +++ b/test/fixedbugs/bug307.go @@ -5,11 +5,11 @@ // license that can be found in the LICENSE file. // Valid program, gccgo reported an error. -// bug307.go:14:6: error: cmplx arguments must have identical types +// bug307.go:14:6: error: complex arguments must have identical types package main func main() { var f float64 - _ = cmplx(1 / f, 0) + _ = complex(1/f, 0) } diff --git a/test/fixedbugs/bug315.go b/test/fixedbugs/bug315.go index 198bae77a..c59ef29e6 100644 --- a/test/fixedbugs/bug315.go +++ b/test/fixedbugs/bug315.go @@ -9,7 +9,7 @@ package main func main() { - a := cmplx(2, 2) + a := complex(2, 2) a /= 2 } diff --git a/test/fixedbugs/bug316.go b/test/fixedbugs/bug316.go index bd4d99eb6..2146408a1 100644 --- a/test/fixedbugs/bug316.go +++ b/test/fixedbugs/bug316.go @@ -9,7 +9,7 @@ package main const ( - c = cmplx(1, 2) + c = complex(1, 2) r = real(c) // was: const initializer must be constant i = imag(c) // was: const initializer must be constant ) diff --git a/test/fixedbugs/bug318.go b/test/fixedbugs/bug318.go new file mode 100644 index 000000000..9c46a0426 --- /dev/null +++ b/test/fixedbugs/bug318.go @@ -0,0 +1,12 @@ +// errchk $G $D/$F.go + +// Copyright 2011 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Issue 1411. + +package main + +const ui uint = 0 +const i int = ui // ERROR "type" diff --git a/test/fixedbugs/bug319.go b/test/fixedbugs/bug319.go new file mode 100644 index 000000000..f60eee4fb --- /dev/null +++ b/test/fixedbugs/bug319.go @@ -0,0 +1,22 @@ +// $G $D/$F.go + +// Copyright 2011 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package main + +import "unsafe" + +func main() { + var x int + + a := uint64(uintptr(unsafe.Pointer(&x))) + b := uint32(uintptr(unsafe.Pointer(&x))) + c := uint16(uintptr(unsafe.Pointer(&x))) + d := int64(uintptr(unsafe.Pointer(&x))) + e := int32(uintptr(unsafe.Pointer(&x))) + f := int16(uintptr(unsafe.Pointer(&x))) + + _, _, _, _, _, _ = a, b, c, d, e, f +} diff --git a/test/func.go b/test/func.go index 0c1a07979..e8ed928bc 100644 --- a/test/func.go +++ b/test/func.go @@ -21,10 +21,10 @@ func f2(a int) { } func f3(a, b int) int { - return a+b + return a + b } -func f4(a, b int, c float) int { +func f4(a, b int, c float32) int { return (a+b)/2 + int(c) } @@ -36,12 +36,12 @@ func f6(a int) (r int) { return 6 } -func f7(a int) (x int, y float) { +func f7(a int) (x int, y float32) { return 7, 7.0 } -func f8(a int) (x int, y float) { +func f8(a int) (x int, y float32) { return 8, 8.0 } @@ -49,12 +49,12 @@ type T struct { x, y int } -func (t *T) m10(a int, b float) int { - return (t.x+a) * (t.y+int(b)) +func (t *T) m10(a int, b float32) int { + return (t.x + a) * (t.y + int(b)) } -func f9(a int) (i int, f float) { +func f9(a int) (i int, f float32) { i = 9 f = 9.0 return diff --git a/test/func1.go b/test/func1.go index 56f4dfcba..056ff9877 100644 --- a/test/func1.go +++ b/test/func1.go @@ -8,11 +8,11 @@ package main -func f1(a int) (int, float) { // BUG (not caught by compiler): multiple return values must have names +func f1(a int) (int, float32) { // BUG (not caught by compiler): multiple return values must have names return 7, 7.0 } -func f2(a int) (a int, b float) { // ERROR "redeclared|definition" +func f2(a int) (a int, b float32) { // ERROR "redeclared|definition" return 8, 8.0 } diff --git a/test/garbage/Makefile b/test/garbage/Makefile index ab29e0956..e83384382 100644 --- a/test/garbage/Makefile +++ b/test/garbage/Makefile @@ -11,8 +11,8 @@ ALL=\ all: $(addsuffix .out, $(ALL)) -%.$O: %.go - $(GC) $*.go +%.$O: %.go stats.go + $(GC) $*.go stats.go %.out: %.$O $(LD) -o $@ $*.$O diff --git a/test/garbage/parser.go b/test/garbage/parser.go index cf68737fb..19a96bc63 100644 --- a/test/garbage/parser.go +++ b/test/garbage/parser.go @@ -11,13 +11,19 @@ import ( "fmt" "go/ast" "go/parser" + "go/token" "os" "path" "runtime" "strings" "time" + "http" + _ "http/pprof" + "log" ) +var serve = flag.String("serve", "", "serve http on this address at end") + func isGoFile(dir *os.FileInfo) bool { return dir.IsRegular() && !strings.HasPrefix(dir.Name, ".") && // ignore .files @@ -30,7 +36,7 @@ func isPkgFile(dir *os.FileInfo) bool { } func pkgName(filename string) string { - file, err := parser.ParseFile(filename, nil, parser.PackageClauseOnly) + file, err := parser.ParseFile(token.NewFileSet(), filename, nil, parser.PackageClauseOnly) if err != nil || file == nil { return "" } @@ -58,7 +64,7 @@ func parseDir(dirpath string) map[string]*ast.Package { } // get package AST - pkgs, err := parser.ParseDir(dirpath, filter, parser.ParseComments) + pkgs, err := parser.ParseDir(token.NewFileSet(), dirpath, filter, parser.ParseComments) if err != nil { println("parse", dirpath, err.String()) panic("fail") @@ -67,12 +73,19 @@ func parseDir(dirpath string) map[string]*ast.Package { } func main() { + runtime.GOMAXPROCS(4) + go func() {}() + go func() {}() + go func() {}() st := &runtime.MemStats + packages = append(packages, packages...) + packages = append(packages, packages...) n := flag.Int("n", 4, "iterations") p := flag.Int("p", len(packages), "# of packages to keep in memory") flag.BoolVar(&st.DebugGC, "d", st.DebugGC, "print GC debugging info (pause times)") flag.Parse() + var lastParsed []map[string]*ast.Package var t0 int64 pkgroot := runtime.GOROOT() + "/src/pkg/" for pass := 0; pass < 2; pass++ { @@ -81,7 +94,7 @@ func main() { // than the normal pauses and would otherwise make // the average look much better than it actually is. st.NumGC = 0 - st.PauseNs = 0 + st.PauseTotalNs = 0 t0 = time.Nanoseconds() for i := 0; i < *n; i++ { @@ -89,25 +102,34 @@ func main() { for j := range parsed { parsed[j] = parseDir(pkgroot + packages[j%len(packages)]) } + if i+1 == *n && *serve != "" { + lastParsed = parsed + } } runtime.GC() + runtime.GC() } t1 := time.Nanoseconds() fmt.Printf("Alloc=%d/%d Heap=%d Mallocs=%d PauseTime=%.3f/%d = %.3f\n", st.Alloc, st.TotalAlloc, st.Sys, - st.Mallocs, float64(st.PauseNs)/1e9, - st.NumGC, float64(st.PauseNs)/1e9/float64(st.NumGC)) - - fmt.Printf("%10s %10s %10s\n", "size", "#alloc", "#free") - for _, s := range st.BySize { - fmt.Printf("%10d %10d %10d\n", s.Size, s.Mallocs, s.Frees) - } + st.Mallocs, float64(st.PauseTotalNs)/1e9, + st.NumGC, float64(st.PauseTotalNs)/1e9/float64(st.NumGC)) + /* + fmt.Printf("%10s %10s %10s\n", "size", "#alloc", "#free") + for _, s := range st.BySize { + fmt.Printf("%10d %10d %10d\n", s.Size, s.Mallocs, s.Frees) + } + */ // Standard gotest benchmark output, collected by build dashboard. - fmt.Printf("garbage.BenchmarkParser %d %d ns/op\n", *n, (t1-t0)/int64(*n)) - fmt.Printf("garbage.BenchmarkParserPause %d %d ns/op\n", st.NumGC, int64(st.PauseNs)/int64(st.NumGC)) + gcstats("BenchmarkParser", *n, t1-t0) + + if *serve != "" { + log.Fatal(http.ListenAndServe(*serve, nil)) + println(lastParsed) + } } @@ -183,7 +205,6 @@ var packages = []string{ "math", "mime", "net", - "nntp", "os", "os/signal", "patch", @@ -195,6 +216,7 @@ var packages = []string{ "runtime", "scanner", "sort", + "smtp", "strconv", "strings", "sync", diff --git a/test/garbage/peano.go b/test/garbage/peano.go index b026354e8..b4d318561 100644 --- a/test/garbage/peano.go +++ b/test/garbage/peano.go @@ -123,7 +123,6 @@ func verify() { func main() { - st := &runtime.MemStats t0 := time.Nanoseconds() verify() for i := 0; i <= 9; i++ { @@ -132,6 +131,5 @@ func main() { runtime.GC() t1 := time.Nanoseconds() - fmt.Printf("garbage.BenchmarkPeano 1 %d ns/op\n", t1-t0) - fmt.Printf("garbage.BenchmarkPeanoPause %d %d ns/op\n", st.NumGC, int64(st.PauseNs)/int64(st.NumGC)) + gcstats("BenchmarkPeano", 1, t1-t0) } diff --git a/test/garbage/stats.go b/test/garbage/stats.go new file mode 100644 index 000000000..474e6ad4a --- /dev/null +++ b/test/garbage/stats.go @@ -0,0 +1,44 @@ +// Copyright 2010 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package main + +import ( + "fmt" + "runtime" + "sort" +) + +func gcstats(name string, n int, t int64) { + st := &runtime.MemStats + fmt.Printf("garbage.%sMem Alloc=%d/%d Heap=%d NextGC=%d Mallocs=%d\n", name, st.Alloc, st.TotalAlloc, st.Sys, st.NextGC, st.Mallocs) + fmt.Printf("garbage.%s %d %d ns/op\n", name, n, t/int64(n)) + fmt.Printf("garbage.%sLastPause 1 %d ns/op\n", name, st.PauseNs[(st.NumGC-1)%uint32(len(st.PauseNs))]) + fmt.Printf("garbage.%sPause %d %d ns/op\n", name, st.NumGC, int64(st.PauseTotalNs)/int64(st.NumGC)) + nn := int(st.NumGC) + if nn >= len(st.PauseNs) { + nn = len(st.PauseNs) + } + t1, t2, t3, t4, t5 := tukey5(st.PauseNs[0:nn]) + fmt.Printf("garbage.%sPause5: %d %d %d %d %d\n", name, t1, t2, t3, t4, t5) + +// fmt.Printf("garbage.%sScan: %v\n", name, st.ScanDist) +} + +type T []uint64 +func (t T) Len() int { return len(t) } +func (t T) Swap(i, j int) { t[i], t[j] = t[j], t[i] } +func (t T) Less(i, j int) bool { return t[i] < t[j] } + +func tukey5(raw []uint64) (lo, q1, q2, q3, hi uint64) { + x := make(T, len(raw)) + copy(x, raw) + sort.Sort(T(x)) + lo = x[0] + q1 = x[len(x)/4] + q2 = x[len(x)/2] + q3 = x[len(x)*3/4] + hi = x[len(x)-1] + return +} diff --git a/test/garbage/tree.go b/test/garbage/tree.go index 816693fbe..c5eae9760 100644 --- a/test/garbage/tree.go +++ b/test/garbage/tree.go @@ -39,7 +39,6 @@ package main import ( "flag" "fmt" - "runtime" "time" ) @@ -95,10 +94,7 @@ func main() { fmt.Printf("long lived tree of depth %d\t check: %d\n", maxDepth, longLivedTree.itemCheck()) t1 := time.Nanoseconds() - st := &runtime.MemStats // Standard gotest benchmark output, collected by build dashboard. - fmt.Printf("garbage.BenchmarkTree %d %d ns/op\n", *n, (t1-t0)/int64(*n)) - fmt.Printf("garbage.BenchmarkTreePause %d %d ns/op\n", st.NumGC, int64(st.PauseNs)/int64(st.NumGC)) - + gcstats("BenchmarkTree", *n, t1-t0) } diff --git a/test/golden.out b/test/golden.out index e587912a4..425771b4a 100644 --- a/test/golden.out +++ b/test/golden.out @@ -4,22 +4,18 @@ =========== ./cmp2.go panic: runtime error: comparing uncomparable type []int -panic PC=xxx =========== ./cmp3.go panic: runtime error: comparing uncomparable type []int -panic PC=xxx =========== ./cmp4.go panic: runtime error: hash of unhashable type []int -panic PC=xxx =========== ./cmp5.go panic: runtime error: hash of unhashable type []int -panic PC=xxx =========== ./deferprint.go printing: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 @@ -64,7 +60,6 @@ Hello World! =========== ken/cplx3.go (+1.292308e+000-1.384615e-001i) (+1.292308e+000-1.384615e-001i) -64 =========== ken/cplx4.go c = (-5.000000-6.000000i) @@ -117,12 +112,10 @@ PASS =========== interface/fail.go panic: interface conversion: *main.S is not main.I: missing method Foo -panic PC=xxx =========== interface/returntype.go panic: interface conversion: *main.S is not main.I2: missing method Name -panic PC=xxx == nilptr/ @@ -130,9 +123,6 @@ panic PC=xxx == fixedbugs/ -=========== fixedbugs/bug016.go -fixedbugs/bug016.go:11: constant -3 overflows uint - =========== fixedbugs/bug027.go hi 0 44444 @@ -155,21 +145,16 @@ inner loop top i 0 do break broke -=========== fixedbugs/bug081.go -fixedbugs/bug081.go:9: typechecking loop - =========== fixedbugs/bug093.go M =========== fixedbugs/bug113.go panic: interface conversion: interface is int, not int32 -panic PC=xxx =========== fixedbugs/bug148.go 2 3 panic: interface conversion: interface is main.T, not main.T -panic PC=xxx == bugs/ diff --git a/test/interface/explicit.go b/test/interface/explicit.go index b952f8fc8..b6a582fff 100644 --- a/test/interface/explicit.go +++ b/test/interface/explicit.go @@ -51,21 +51,25 @@ func main() { t = T(e) // ERROR "need explicit|need type assertion|incompatible" } -type M interface { M() } +type M interface { + M() +} + var m M -var _ = m.(int) // ERROR "impossible type assertion" +var _ = m.(int) // ERROR "impossible type assertion" type Int int -func (Int) M(float) {} -var _ = m.(Int) // ERROR "impossible type assertion" +func (Int) M(float64) {} + +var _ = m.(Int) // ERROR "impossible type assertion" var ii int var jj Int -var m1 M = ii // ERROR "incompatible|missing" -var m2 M = jj // ERROR "incompatible|wrong type for M method" +var m1 M = ii // ERROR "incompatible|missing" +var m2 M = jj // ERROR "incompatible|wrong type for M method" -var m3 = M(ii) // ERROR "invalid|missing" -var m4 = M(jj) // ERROR "invalid|wrong type for M method" +var m3 = M(ii) // ERROR "invalid|missing" +var m4 = M(jj) // ERROR "invalid|wrong type for M method" diff --git a/test/iota.go b/test/iota.go index 20b77c6cc..c40ca1f38 100644 --- a/test/iota.go +++ b/test/iota.go @@ -17,8 +17,8 @@ const ( x int = iota y = iota z = 1 << iota - f float = 2 * iota - g float = 4.5 * float(iota) + f float32 = 2 * iota + g float32 = 4.5 * float32(iota) ) const ( @@ -57,7 +57,7 @@ const ( ) const ( - p = float(iota) + p = float32(iota) q r ) @@ -68,9 +68,9 @@ const ( ) const ( - abit, amask = 1 << iota, 1 << iota - 1 - bbit, bmask = 1 << iota, 1 << iota - 1 - cbit, cmask = 1 << iota, 1 << iota - 1 + abit, amask = 1 << iota, 1<<iota - 1 + bbit, bmask = 1 << iota, 1<<iota - 1 + cbit, cmask = 1 << iota, 1<<iota - 1 ) func main() { diff --git a/test/ken/cplx0.go b/test/ken/cplx0.go index 6e9bfd023..ba1fa196f 100644 --- a/test/ken/cplx0.go +++ b/test/ken/cplx0.go @@ -13,7 +13,7 @@ const ( C1 = R + I // ADD(5,6) ) -func doprint(c complex) { println(c) } +func doprint(c complex128) { println(c) } func main() { diff --git a/test/ken/cplx1.go b/test/ken/cplx1.go index 26b113992..8ec7d40f5 100644 --- a/test/ken/cplx1.go +++ b/test/ken/cplx1.go @@ -48,7 +48,7 @@ func main() { booltest(6+9i, false) } -func booltest(a complex, r bool) { +func booltest(a complex64, r bool) { var b bool b = a == C1 diff --git a/test/ken/cplx2.go b/test/ken/cplx2.go index 5a66dc9a9..b36e93ecd 100644 --- a/test/ken/cplx2.go +++ b/test/ken/cplx2.go @@ -28,13 +28,13 @@ const ( func main() { - r := 5 + 0i + var r complex64 = 5 + 0i if r != R { println("opcode 1", r, R) panic("fail") } - i := 6i + var i complex64 = 6i if i != I { println("opcode 2", i, I) panic("fail") diff --git a/test/ken/cplx3.go b/test/ken/cplx3.go index 997894b41..83acc15ff 100644 --- a/test/ken/cplx3.go +++ b/test/ken/cplx3.go @@ -16,24 +16,18 @@ const ( C1 = R + I // ADD(5,6) ) -var complexBits = reflect.Typeof(complex(0i)).Size() * 8 - func main() { c0 := C1 c0 = (c0 + c0 + c0) / (c0 + c0 + 3i) println(c0) - c := *(*complex)(unsafe.Pointer(&c0)) + c := *(*complex128)(unsafe.Pointer(&c0)) println(c) - println(complexBits) - var a interface{} switch c := reflect.NewValue(a).(type) { case *reflect.ComplexValue: - if complexBits == 64 { - v := c.Get() - _, _ = complex64(v), true - } + v := c.Get() + _, _ = complex128(v), true } } diff --git a/test/ken/cplx4.go b/test/ken/cplx4.go index 3c6f1f68c..8524e47ae 100644 --- a/test/ken/cplx4.go +++ b/test/ken/cplx4.go @@ -15,7 +15,7 @@ const ( C1 = R + I // ADD(5,6) ) -func doprint(c complex) { fmt.Printf("c = %f\n", c) } +func doprint(c complex128) { fmt.Printf("c = %f\n", c) } func main() { @@ -32,12 +32,12 @@ func main() { c2 := complex128(C1) fmt.Printf("c = %G\n", c2) - // real, imag, cmplx - c3 := cmplx(real(c2)+3, imag(c2)-5) + c2 + // real, imag, complex + c3 := complex(real(c2)+3, imag(c2)-5) + c2 fmt.Printf("c = %G\n", c3) // compiler used to crash on nested divide - c4 := cmplx(real(c3/2), imag(c3/2)) + c4 := complex(real(c3/2), imag(c3/2)) if c4 != c3/2 { fmt.Printf("BUG: c3 = %G != c4 = %G\n", c3, c4) } diff --git a/test/ken/cplx5.go b/test/ken/cplx5.go index af2a1c57d..d425a7c4c 100644 --- a/test/ken/cplx5.go +++ b/test/ken/cplx5.go @@ -6,49 +6,49 @@ package main -var a [12]complex -var s []complex -var c chan complex +var a [12]complex128 +var s []complex128 +var c chan complex128 var f struct { - c complex + c complex128 } -var m map[complex]complex +var m map[complex128]complex128 func main() { - // array of complex + // array of complex128 for i := 0; i < len(a); i++ { - a[i] = cmplx(float(i), float(-i)) + a[i] = complex(float64(i), float64(-i)) } println(a[5]) - // slice of complex - s = make([]complex, len(a)) + // slice of complex128 + s = make([]complex128, len(a)) for i := 0; i < len(s); i++ { s[i] = a[i] } println(s[5]) // chan - c = make(chan complex) + c = make(chan complex128) go chantest(c) println(<-c) - // pointer of complex + // pointer of complex128 v := a[5] pv := &v println(*pv) - // field of complex + // field of complex128 f.c = a[5] println(f.c) - // map of complex - m = make(map[complex]complex) + // map of complex128 + m = make(map[complex128]complex128) for i := 0; i < len(s); i++ { m[-a[i]] = a[i] } println(m[5i-5]) - println(m[cmplx(-5, 5)]) + println(m[complex(-5, 5)]) } -func chantest(c chan complex) { c <- a[5] } +func chantest(c chan complex128) { c <- a[5] } diff --git a/test/ken/robfunc.go b/test/ken/robfunc.go index 12b4b6d7b..6b3d4b2e4 100644 --- a/test/ken/robfunc.go +++ b/test/ken/robfunc.go @@ -8,8 +8,8 @@ package main func assertequal(is, shouldbe int, msg string) { if is != shouldbe { - print("assertion fail" + msg + "\n"); - panic(1); + print("assertion fail" + msg + "\n") + panic(1) } } @@ -20,75 +20,75 @@ func f2(a int) { } func f3(a, b int) int { - return a+b; + return a + b } -func f4(a, b int, c float) int { - return (a+b)/2 + int(c); +func f4(a, b int, c float64) int { + return (a+b)/2 + int(c) } func f5(a int) int { - return 5; + return 5 } func f6(a int) (r int) { - return 6; + return 6 } -func f7(a int) (x int, y float) { - return 7, 7.0; +func f7(a int) (x int, y float64) { + return 7, 7.0 } -func f8(a int) (x int, y float) { - return 8, 8.0; +func f8(a int) (x int, y float64) { + return 8, 8.0 } type T struct { - x, y int; + x, y int } -func (t *T) m10(a int, b float) int { - return (t.x+a) * (t.y+int(b)); +func (t *T) m10(a int, b float64) int { + return (t.x + a) * (t.y + int(b)) } -func f9(a int) (in int, fl float) { - i := 9; - f := float(9); - return i, f; +func f9(a int) (in int, fl float64) { + i := 9 + f := float64(9) + return i, f } func main() { - f1(); - f2(1); - r3 := f3(1, 2); - assertequal(r3, 3, "3"); - r4 := f4(0, 2, 3.0); - assertequal(r4, 4, "4"); - r5 := f5(1); - assertequal(r5, 5, "5"); - r6 := f6(1); - assertequal(r6, 6, "6"); - var r7 int; - var s7 float; - r7, s7 = f7(1); - assertequal(r7, 7, "r7"); - assertequal(int(s7), 7, "s7"); - var r8 int; - var s8 float; - r8, s8 = f8(1); - assertequal(r8, 8, "r8"); - assertequal(int(s8), 8, "s8"); - var r9 int; - var s9 float; - r9, s9 = f9(1); - assertequal(r9, 9, "r9"); - assertequal(int(s9), 9, "s9"); - var t *T = new(T); - t.x = 1; - t.y = 2; - r10 := t.m10(1, 3.0); - assertequal(r10, 10, "10"); + f1() + f2(1) + r3 := f3(1, 2) + assertequal(r3, 3, "3") + r4 := f4(0, 2, 3.0) + assertequal(r4, 4, "4") + r5 := f5(1) + assertequal(r5, 5, "5") + r6 := f6(1) + assertequal(r6, 6, "6") + var r7 int + var s7 float64 + r7, s7 = f7(1) + assertequal(r7, 7, "r7") + assertequal(int(s7), 7, "s7") + var r8 int + var s8 float64 + r8, s8 = f8(1) + assertequal(r8, 8, "r8") + assertequal(int(s8), 8, "s8") + var r9 int + var s9 float64 + r9, s9 = f9(1) + assertequal(r9, 9, "r9") + assertequal(int(s9), 9, "s9") + var t *T = new(T) + t.x = 1 + t.y = 2 + r10 := t.m10(1, 3.0) + assertequal(r10, 10, "10") } diff --git a/test/ken/simpconv.go b/test/ken/simpconv.go index cb443e3a1..feb85d299 100644 --- a/test/ken/simpconv.go +++ b/test/ken/simpconv.go @@ -6,20 +6,23 @@ package main -type vlong int64; -type short int16; +type vlong int64 +type short int16 -func -main() { - s1 := vlong(0); - for i:=short(0); i<10; i=i+1 { - s1 = s1 + vlong(i); +func main() { + s1 := vlong(0) + for i := short(0); i < 10; i = i + 1 { + s1 = s1 + vlong(i) + } + if s1 != 45 { + panic(s1) } - if s1 != 45 { panic(s1); } - s2 := float(0); - for i:=0; i<10; i=i+1 { - s2 = s2 + float(i); + s2 := float64(0) + for i := 0; i < 10; i = i + 1 { + s2 = s2 + float64(i) + } + if s2 != 45 { + panic(s2) } - if s2 != 45 { panic(s2); } } diff --git a/test/ken/slicearray.go b/test/ken/slicearray.go index 6e7088e19..5c31270fc 100644 --- a/test/ken/slicearray.go +++ b/test/ken/slicearray.go @@ -8,8 +8,8 @@ package main var bx [10]byte var by []byte -var fx [10]float -var fy []float +var fx [10]float64 +var fy []float64 var lb, hb int var t int @@ -87,7 +87,7 @@ func main() { by = bx[2:8] tstb() - // width 4 (float) + // width 4 (float64) lb = 0 hb = 10 fy = fx[lb:hb] @@ -204,7 +204,7 @@ func init() { by = nil for i := 0; i < len(fx); i++ { - fx[i] = float(i + 20) + fx[i] = float64(i + 20) } fy = nil } diff --git a/test/ken/sliceslice.go b/test/ken/sliceslice.go index 5a35acaf4..639042128 100644 --- a/test/ken/sliceslice.go +++ b/test/ken/sliceslice.go @@ -8,8 +8,8 @@ package main var bx []byte var by []byte -var fx []float -var fy []float +var fx []float64 +var fy []float64 var lb, hb int var t int @@ -78,7 +78,7 @@ func main() { by = bx[2:8] tstb() - // width 4 (float) + // width 4 (float64) lb = 0 hb = 10 fy = fx[lb:hb] @@ -195,9 +195,9 @@ func init() { } by = nil - fx = make([]float, 10) + fx = make([]float64, 10) for i := 0; i < len(fx); i++ { - fx[i] = float(i + 20) + fx[i] = float64(i + 20) } fy = nil } diff --git a/test/literal.go b/test/literal.go index 9bdbabca8..bf0538812 100644 --- a/test/literal.go +++ b/test/literal.go @@ -18,7 +18,7 @@ func assert(cond bool, msg string) { } } -func equal(a, b float) bool { +func equal(a, b float32) bool { return a == b } @@ -116,23 +116,23 @@ func main() { _, _, _, _ = u30, u31, u32, u33 // float - var f00 float = 3.14159 - var f01 float = -3.14159 - var f02 float = +3.14159 - var f03 float = 0.0 - var f04 float = .0 - var f05 float = 0. - var f06 float = -0.0 - var f07 float = 1e10 - var f08 float = -1e10 - var f09 float = 1e-10 - var f10 float = 1e+10 - var f11 float = 1.e-10 - var f12 float = 1.e+10 - var f13 float = .1e-10 - var f14 float = .1e+10 - var f15 float = 1.1e-10 - var f16 float = 1.1e+10 + var f00 float32 = 3.14159 + var f01 float32 = -3.14159 + var f02 float32 = +3.14159 + var f03 float32 = 0.0 + var f04 float32 = .0 + var f05 float32 = 0. + var f06 float32 = -0.0 + var f07 float32 = 1e10 + var f08 float32 = -1e10 + var f09 float32 = 1e-10 + var f10 float32 = 1e+10 + var f11 float32 = 1.e-10 + var f12 float32 = 1.e+10 + var f13 float32 = .1e-10 + var f14 float32 = .1e+10 + var f15 float32 = 1.1e-10 + var f16 float32 = 1.1e+10 assert(f01 == -f00, "f01") assert(f02 == -f01, "f02") assert(f03 == f04, "f03") diff --git a/test/map.go b/test/map.go index ddff7c7a7..c3963499b 100644 --- a/test/map.go +++ b/test/map.go @@ -21,73 +21,73 @@ func P(a []string) string { } s += `"` + a[i] + `"` } - s +="}" + s += "}" return s } func main() { // Test a map literal. - mlit := map[string] int { "0":0, "1":1, "2":2, "3":3, "4":4 } + mlit := map[string]int{"0": 0, "1": 1, "2": 2, "3": 3, "4": 4} for i := 0; i < len(mlit); i++ { - s := string([]byte{byte(i)+'0'}) + s := string([]byte{byte(i) + '0'}) if mlit[s] != i { fmt.Printf("mlit[%s] = %d\n", s, mlit[s]) } } - mib := make(map[int] bool) - mii := make(map[int] int) - mfi := make(map[float] int) - mif := make(map[int] float) - msi := make(map[string] int) - mis := make(map[int] string) - mss := make(map[string] string) - mspa := make(map[string] []string) + mib := make(map[int]bool) + mii := make(map[int]int) + mfi := make(map[float32]int) + mif := make(map[int]float32) + msi := make(map[string]int) + mis := make(map[int]string) + mss := make(map[string]string) + mspa := make(map[string][]string) // BUG need an interface map both ways too type T struct { - i int64 // can't use string here; struct values are only compared at the top level - f float + i int64 // can't use string here; struct values are only compared at the top level + f float32 } - mipT := make(map[int] *T) - mpTi := make(map[*T] int) - mit := make(map[int] T) -// mti := make(map[T] int) + mipT := make(map[int]*T) + mpTi := make(map[*T]int) + mit := make(map[int]T) + // mti := make(map[T] int) - type M map[int] int - mipM := make(map[int] M) + type M map[int]int + mipM := make(map[int]M) - var apT [2*count]*T + var apT [2 * count]*T for i := 0; i < count; i++ { s := strconv.Itoa(i) - s10 := strconv.Itoa(i*10) - f := float(i) - t := T{int64(i),f} + s10 := strconv.Itoa(i * 10) + f := float32(i) + t := T{int64(i), f} apT[i] = new(T) apT[i].i = int64(i) apT[i].f = f - apT[2*i] = new(T) // need twice as many entries as we use, for the nonexistence check + apT[2*i] = new(T) // need twice as many entries as we use, for the nonexistence check apT[2*i].i = int64(i) apT[2*i].f = f - m := M{i: i+1} + m := M{i: i + 1} mib[i] = (i != 0) - mii[i] = 10*i - mfi[float(i)] = 10*i - mif[i] = 10.0*f + mii[i] = 10 * i + mfi[float32(i)] = 10 * i + mif[i] = 10.0 * f mis[i] = s msi[s] = i mss[s] = s10 mss[s] = s10 as := make([]string, 2) - as[0] = s10 - as[1] = s10 + as[0] = s10 + as[1] = s10 mspa[s] = as mipT[i] = apT[i] mpTi[apT[i]] = i mipM[i] = m mit[i] = t - // mti[t] = i + // mti[t] = i } // test len @@ -121,15 +121,15 @@ func main() { if len(mpTi) != count { fmt.Printf("len(mpTi) = %d\n", len(mpTi)) } -// if len(mti) != count { -// fmt.Printf("len(mti) = %d\n", len(mti)) -// } + // if len(mti) != count { + // fmt.Printf("len(mti) = %d\n", len(mti)) + // } if len(mipM) != count { fmt.Printf("len(mipM) = %d\n", len(mipM)) } -// if len(mti) != count { -// fmt.Printf("len(mti) = %d\n", len(mti)) -// } + // if len(mti) != count { + // fmt.Printf("len(mti) = %d\n", len(mti)) + // } if len(mit) != count { fmt.Printf("len(mit) = %d\n", len(mit)) } @@ -137,25 +137,25 @@ func main() { // test construction directly for i := 0; i < count; i++ { s := strconv.Itoa(i) - s10 := strconv.Itoa(i*10) - f := float(i) + s10 := strconv.Itoa(i * 10) + f := float32(i) // BUG m := M(i, i+1) if mib[i] != (i != 0) { fmt.Printf("mib[%d] = %t\n", i, mib[i]) } - if(mii[i] != 10*i) { + if mii[i] != 10*i { fmt.Printf("mii[%d] = %d\n", i, mii[i]) } - if(mfi[f] != 10*i) { + if mfi[f] != 10*i { fmt.Printf("mfi[%d] = %d\n", i, mfi[f]) } - if(mif[i] != 10.0*f) { + if mif[i] != 10.0*f { fmt.Printf("mif[%d] = %g\n", i, mif[i]) } - if(mis[i] != s) { + if mis[i] != s { fmt.Printf("mis[%d] = %s\n", i, mis[i]) } - if(msi[s] != i) { + if msi[s] != i { fmt.Printf("msi[%s] = %d\n", s, msi[s]) } if mss[s] != s10 { @@ -166,22 +166,22 @@ func main() { fmt.Printf("mspa[%s][%d] = %s\n", s, j, mspa[s][j]) } } - if(mipT[i].i != int64(i) || mipT[i].f != f) { + if mipT[i].i != int64(i) || mipT[i].f != f { fmt.Printf("mipT[%d] = %v\n", i, mipT[i]) } - if(mpTi[apT[i]] != i) { + if mpTi[apT[i]] != i { fmt.Printf("mpTi[apT[%d]] = %d\n", i, mpTi[apT[i]]) } - // if(mti[t] != i) { - // fmt.Printf("mti[%s] = %s\n", s, mti[t]) - // } - if (mipM[i][i] != i + 1) { + // if(mti[t] != i) { + // fmt.Printf("mti[%s] = %s\n", s, mti[t]) + // } + if mipM[i][i] != i+1 { fmt.Printf("mipM[%d][%d] = %d\n", i, i, mipM[i][i]) } - // if(mti[t] != i) { - // fmt.Printf("mti[%v] = %d\n", t, mti[t]) - // } - if(mit[i].i != int64(i) || mit[i].f != f) { + // if(mti[t] != i) { + // fmt.Printf("mti[%v] = %d\n", t, mti[t]) + // } + if mit[i].i != int64(i) || mit[i].f != f { fmt.Printf("mit[%d] = {%d %g}\n", i, mit[i].i, mit[i].f) } } @@ -190,7 +190,7 @@ func main() { // failed lookups yield a false value for the boolean. for i := 0; i < count; i++ { s := strconv.Itoa(i) - f := float(i) + f := float32(i) { _, b := mib[i] if !b { @@ -311,23 +311,23 @@ func main() { fmt.Printf("tuple existence assign: mit[%d]\n", i) } } -// { -// _, b := mti[t] -// if !b { -// fmt.Printf("tuple existence decl: mti[%d]\n", i) -// } -// _, b = mti[t] -// if !b { -// fmt.Printf("tuple existence assign: mti[%d]\n", i) -// } -// } + // { + // _, b := mti[t] + // if !b { + // fmt.Printf("tuple existence decl: mti[%d]\n", i) + // } + // _, b = mti[t] + // if !b { + // fmt.Printf("tuple existence assign: mti[%d]\n", i) + // } + // } } // test nonexistence with tuple check // failed lookups yield a false value for the boolean. for i := count; i < 2*count; i++ { s := strconv.Itoa(i) - f := float(i) + f := float32(i) { _, b := mib[i] if b { @@ -438,16 +438,16 @@ func main() { fmt.Printf("tuple nonexistence assign: mipM[%d]", i) } } -// { -// _, b := mti[t] -// if b { -// fmt.Printf("tuple nonexistence decl: mti[%d]", i) -// } -// _, b = mti[t] -// if b { -// fmt.Printf("tuple nonexistence assign: mti[%d]", i) -// } -// } + // { + // _, b := mti[t] + // if b { + // fmt.Printf("tuple nonexistence decl: mti[%d]", i) + // } + // _, b = mti[t] + // if b { + // fmt.Printf("tuple nonexistence assign: mti[%d]", i) + // } + // } { _, b := mit[i] if b { @@ -460,32 +460,31 @@ func main() { } } - // tests for structured map element updates for i := 0; i < count; i++ { s := strconv.Itoa(i) - mspa[s][i % 2] = "deleted" - if mspa[s][i % 2] != "deleted" { - fmt.Printf("update mspa[%s][%d] = %s\n", s, i %2, mspa[s][i % 2]) + mspa[s][i%2] = "deleted" + if mspa[s][i%2] != "deleted" { + fmt.Printf("update mspa[%s][%d] = %s\n", s, i%2, mspa[s][i%2]) } mipT[i].i += 1 if mipT[i].i != int64(i)+1 { fmt.Printf("update mipT[%d].i = %d\n", i, mipT[i].i) } - mipT[i].f = float(i + 1) - if (mipT[i].f != float(i + 1)) { + mipT[i].f = float32(i + 1) + if mipT[i].f != float32(i+1) { fmt.Printf("update mipT[%d].f = %g\n", i, mipT[i].f) } mipM[i][i]++ - if mipM[i][i] != (i + 1) + 1 { + if mipM[i][i] != (i+1)+1 { fmt.Printf("update mipM[%d][%d] = %i\n", i, i, mipM[i][i]) } } // test range on nil map - var mnil map[string] int + var mnil map[string]int for _, _ = range mnil { panic("range mnil") } diff --git a/test/method1.go b/test/method1.go index 1a2f8cae5..ec14ef9e4 100644 --- a/test/method1.go +++ b/test/method1.go @@ -8,10 +8,10 @@ package main type T struct { } func (t *T) M(int, string) // GCCGO_ERROR "previous" -func (t *T) M(int, float) { } // ERROR "redeclared|redefinition" +func (t *T) M(int, float64) { } // ERROR "redeclared|redefinition" func f(int, string) // GCCGO_ERROR "previous" -func f(int, float) { } // ERROR "redeclared|redefinition" +func f(int, float64) { } // ERROR "redeclared|redefinition" func g(a int, b string) // GCCGO_ERROR "previous" func g(a int, c string) // ERROR "redeclared|redefinition" diff --git a/test/named.go b/test/named.go index d2039bab4..5b6bb81fe 100644 --- a/test/named.go +++ b/test/named.go @@ -12,7 +12,7 @@ package main type Array [10]byte type Bool bool type Chan chan int -type Float float +type Float float32 type Int int type Map map[int]byte type Slice []byte diff --git a/test/named1.go b/test/named1.go index 600e502f9..1776313f0 100644 --- a/test/named1.go +++ b/test/named1.go @@ -43,12 +43,9 @@ func main() { _, b = m[2] // ERROR "cannot .* bool.*type Bool" m[2] = 1, b // ERROR "cannot use.*type Bool.*as type bool" - b = c <- 1 // ERROR "cannot use.*type bool.*type Bool" - _ = b - asBool(c <- 1) // ERROR "cannot use.*type bool.*as type Bool" - - _, b = <-c // ERROR "cannot .* bool.*type Bool" - _ = b + ////TODO(rsc): uncomment when this syntax is valid for receive+check closed + //// _, b = <-c // ERROR "cannot .* bool.*type Bool" + //// _ = b var inter interface{} _, b = inter.(Map) // ERROR "cannot .* bool.*type Bool" diff --git a/test/nil.go b/test/nil.go index 6a72b72eb..4f4c75527 100644 --- a/test/nil.go +++ b/test/nil.go @@ -10,14 +10,13 @@ type T struct { i int } -type IN interface { -} +type IN interface{} func main() { var i *int - var f *float + var f *float32 var s *string - var m map[float] *int + var m map[float32]*int var c chan int var t *T var in IN diff --git a/test/recover2.go b/test/recover2.go index f33af4457..9affe25d4 100644 --- a/test/recover2.go +++ b/test/recover2.go @@ -58,7 +58,7 @@ func test3() { func test4() { defer mustRecover("interface") var x interface{} = 1 - println(x.(float)) + println(x.(float32)) } type T struct { @@ -42,7 +42,9 @@ TMP2FILE=/tmp/gotest2-$$-$USER # don't run the machine out of memory: limit individual processes to 4GB. # on thresher, 3GB suffices to run the tests; with 2GB, peano fails. -ulimit -v 4000000 +# Linux charges reserved but not mapped addresses to ulimit -v +# so we have to use ulimit -m. +ulimit -m 4000000 # no core files please ulimit -c 0 diff --git a/test/stack.go b/test/stack.go index 816b555a4..1fd57161f 100644 --- a/test/stack.go +++ b/test/stack.go @@ -30,6 +30,32 @@ func d(t T) { } } +func f0() { + // likely to make a new stack for f0, + // because the call to f1 puts 3000 bytes + // in our frame. + f1() +} + +func f1() [3000]byte { + // likely to make a new stack for f1, + // because 3000 bytes were used by f0 + // and we need 3000 more for the call + // to f2. if the call to morestack in f1 + // does not pass the frame size, the new + // stack (default size 5k) will not be big + // enough for the frame, and the morestack + // check in f2 will die, if we get that far + // without faulting. + f2() + return [3000]byte{} +} + +func f2() [3000]byte { + // just take up space + return [3000]byte{} +} + var c = make(chan int) var t T var b = []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10} @@ -40,6 +66,7 @@ func recur(n int) { panic("bad []byte -> string") } go g(c, t) + f0() s := <-c if s != len(t) { println("bad go", s) diff --git a/test/syntax/chan1.go b/test/syntax/chan1.go new file mode 100644 index 000000000..9c12e5e6f --- /dev/null +++ b/test/syntax/chan1.go @@ -0,0 +1,17 @@ +// errchk $G -e $D/$F.go + +// Copyright 2010 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package main + +var c chan int +var v int + +func main() { + if c <- v { // ERROR "send statement.*value.*select" + } +} + +var _ = c <- v // ERROR "send statement.*value.*select" diff --git a/test/syntax/typesw.go b/test/syntax/typesw.go new file mode 100644 index 000000000..47f683cdf --- /dev/null +++ b/test/syntax/typesw.go @@ -0,0 +1,13 @@ +// errchk $G -e $D/$F.go + +// Copyright 2011 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package main + +func main() { + switch main() := interface{}(nil).(type) { // ERROR "invalid variable name" + default: + } +} diff --git a/test/test0.go b/test/test0.go index dd2033a98..d8d86c427 100644 --- a/test/test0.go +++ b/test/test0.go @@ -6,12 +6,11 @@ package main -const - a_const = 0 +const a_const = 0 const ( - pi = /* the usual */ 3.14159265358979323 - e = 2.718281828 + pi = /* the usual */ 3.14159265358979323 + e = 2.718281828 mask1 int = 1 << iota mask2 = 1 << iota mask3 = 1 << iota @@ -19,7 +18,7 @@ const ( ) type ( - Empty interface {} + Empty interface{} Point struct { x, y int } @@ -32,19 +31,21 @@ func (p *Point) Initialize(x, y int) *Point { } func (p *Point) Distance() int { - return p.x * p.x + p.y * p.y + return p.x*p.x + p.y*p.y } var ( - x1 int - x2 int - u, v, w float + x1 int + x2 int + u, v, w float32 ) func foo() {} func min(x, y int) int { - if x < y { return x; } + if x < y { + return x + } return y } @@ -57,24 +58,29 @@ func swap(x, y int) (u, v int) { func control_structs() { var p *Point = new(Point).Initialize(2, 3) i := p.Distance() - var f float = 0.3 + var f float32 = 0.3 _ = f - for {} - for {} + for { + } + for { + } for j := 0; j < i; j++ { if i == 0 { - } else i = 0 - var x float + } else { + i = 0 + } + var x float32 _ = x } - foo: // a label +foo: // a label var j int switch y := 0; true { case i < y: fallthrough case i < j: case i == 0, i == 1, i == j: - i++; i++ + i++ + i++ goto foo default: i = -+-+i diff --git a/test/typeswitch.go b/test/typeswitch.go index 9e6d10ea8..83fb0985a 100644 --- a/test/typeswitch.go +++ b/test/typeswitch.go @@ -21,12 +21,15 @@ const ( Last ) -type S struct { a int } +type S struct { + a int +} + var s S = S{1234} var c = make(chan int) -var a = []int{0,1,2,3} +var a = []int{0, 1, 2, 3} var m = make(map[string]int) @@ -68,10 +71,10 @@ func main() { assert(x == true && i == Bool, "bool") case int: assert(x == 7 && i == Int, "int") - case float: - assert(x == 7.4 && i == Float, "float") + case float64: + assert(x == 7.4 && i == Float, "float64") case string: - assert(x == "hello"&& i == String, "string") + assert(x == "hello" && i == String, "string") case S: assert(x.a == 1234 && i == Struct, "struct") case chan int: diff --git a/test/zerodivide.go b/test/zerodivide.go index cd4f52215..1948528d2 100644 --- a/test/zerodivide.go +++ b/test/zerodivide.go @@ -17,56 +17,90 @@ type Error interface { } type ErrorTest struct { - name string - fn func() - err string + name string + fn func() + err string } var ( - i, j, k int = 0, 0, 1 - i8, j8, k8 int8 = 0, 0, 1 + i, j, k int = 0, 0, 1 + i8, j8, k8 int8 = 0, 0, 1 i16, j16, k16 int16 = 0, 0, 1 i32, j32, k32 int32 = 0, 0, 1 i64, j64, k64 int64 = 0, 0, 1 - u, v, w uint = 0, 0, 1 - u8, v8, w8 uint8 = 0, 0, 1 - u16, v16, w16 uint16 = 0, 0, 1 - u32, v32, w32 uint32 = 0, 0, 1 - u64, v64, w64 uint64 = 0, 0, 1 - up, vp, wp uintptr = 0, 0, 1 + u, v, w uint = 0, 0, 1 + u8, v8, w8 uint8 = 0, 0, 1 + u16, v16, w16 uint16 = 0, 0, 1 + u32, v32, w32 uint32 = 0, 0, 1 + u64, v64, w64 uint64 = 0, 0, 1 + up, vp, wp uintptr = 0, 0, 1 - f, g, h float = 0, 0, 1 - f32, g32, h32 float32 = 0, 0, 1 + f, g, h float64 = 0, 0, 1 + f32, g32, h32 float32 = 0, 0, 1 f64, g64, h64, inf, negInf, nan float64 = 0, 0, 1, math.Inf(1), math.Inf(-1), math.NaN() - c, d, e complex = 0+0i, 0+0i, 1+1i - c64, d64, e64 complex64 = 0+0i, 0+0i, 1+1i - c128, d128, e128 complex128 = 0+0i, 0+0i, 1+1i + c, d, e complex128 = 0 + 0i, 0 + 0i, 1 + 1i + c64, d64, e64 complex64 = 0 + 0i, 0 + 0i, 1 + 1i + c128, d128, e128 complex128 = 0 + 0i, 0 + 0i, 1 + 1i ) // Fool gccgo into thinking that these variables can change. func NotCalled() { - i++; j++; k++ - i8++; j8++; k8++ - i16++; j16++; k16++ - i32++; j32++; k32++ - i64++; j64++; k64++ - - u++; v++; w++ - u8++; v8++; w8++ - u16++; v16++; w16++ - u32++; v32++; w32++ - u64++; v64++; w64++ - up++; vp++; wp++ - - f += 1; g += 1; h += 1 - f32 += 1; g32 += 1; h32 += 1 - f64 += 1; g64 += 1; h64 += 1 - - c += 1+1i; d += 1+1i; e += 1+1i - c64 += 1+1i; d64 += 1+1i; e64 += 1+1i - c128 += 1+1i; d128 += 1+1i; e128 += 1+1i + i++ + j++ + k++ + i8++ + j8++ + k8++ + i16++ + j16++ + k16++ + i32++ + j32++ + k32++ + i64++ + j64++ + k64++ + + u++ + v++ + w++ + u8++ + v8++ + w8++ + u16++ + v16++ + w16++ + u32++ + v32++ + w32++ + u64++ + v64++ + w64++ + up++ + vp++ + wp++ + + f += 1 + g += 1 + h += 1 + f32 += 1 + g32 += 1 + h32 += 1 + f64 += 1 + g64 += 1 + h64 += 1 + + c += 1 + 1i + d += 1 + 1i + e += 1 + 1i + c64 += 1 + 1i + d64 += 1 + 1i + e64 += 1 + 1i + c128 += 1 + 1i + d128 += 1 + 1i + e128 += 1 + 1i } var tmp interface{} @@ -79,52 +113,52 @@ func use(v interface{}) { // Verify error/no error for all types. var errorTests = []ErrorTest{ // All integer divide by zero should error. - ErrorTest{ "int 0/0", func() { use(i/j) }, "divide", }, - ErrorTest{ "int8 0/0", func() { use(i8/j8) }, "divide", }, - ErrorTest{ "int16 0/0", func() { use(i16/j16) }, "divide", }, - ErrorTest{ "int32 0/0", func() { use(i32/j32) }, "divide", }, - ErrorTest{ "int64 0/0", func() { use(i64/j64) }, "divide", }, - - ErrorTest{ "int 1/0", func() { use(k/j) }, "divide", }, - ErrorTest{ "int8 1/0", func() { use(k8/j8) }, "divide", }, - ErrorTest{ "int16 1/0", func() { use(k16/j16) }, "divide", }, - ErrorTest{ "int32 1/0", func() { use(k32/j32) }, "divide", }, - ErrorTest{ "int64 1/0", func() { use(k64/j64) }, "divide", }, - - ErrorTest{ "uint 0/0", func() { use(u/v) }, "divide", }, - ErrorTest{ "uint8 0/0", func() { use(u8/v8) }, "divide", }, - ErrorTest{ "uint16 0/0", func() { use(u16/v16) }, "divide", }, - ErrorTest{ "uint32 0/0", func() { use(u32/v32) }, "divide", }, - ErrorTest{ "uint64 0/0", func() { use(u64/v64) }, "divide", }, - ErrorTest{ "uintptr 0/0", func() { use(up/vp) }, "divide", }, - - ErrorTest{ "uint 1/0", func() { use(w/v) }, "divide", }, - ErrorTest{ "uint8 1/0", func() { use(w8/v8) }, "divide", }, - ErrorTest{ "uint16 1/0", func() { use(w16/v16) }, "divide", }, - ErrorTest{ "uint32 1/0", func() { use(w32/v32) }, "divide", }, - ErrorTest{ "uint64 1/0", func() { use(w64/v64) }, "divide", }, - ErrorTest{ "uintptr 1/0", func() { use(wp/vp) }, "divide", }, - - // All floating divide by zero should not error. - ErrorTest{ "float 0/0", func() { use(f/g) }, "", }, - ErrorTest{ "float32 0/0", func() { use(f32/g32) }, "", }, - ErrorTest{ "float64 0/0", func() { use(f64/g64) }, "", }, - - ErrorTest{ "float 1/0", func() { use(h/g) }, "", }, - ErrorTest{ "float32 1/0", func() { use(h32/g32) }, "", }, - ErrorTest{ "float64 1/0", func() { use(h64/g64) }, "", }, - ErrorTest{ "float64 inf/0", func() { use(inf/g64) }, "", }, - ErrorTest{ "float64 -inf/0", func() { use(negInf/g64) }, "", }, - ErrorTest{ "float64 nan/0", func() { use(nan/g64) }, "", }, + ErrorTest{"int 0/0", func() { use(i / j) }, "divide"}, + ErrorTest{"int8 0/0", func() { use(i8 / j8) }, "divide"}, + ErrorTest{"int16 0/0", func() { use(i16 / j16) }, "divide"}, + ErrorTest{"int32 0/0", func() { use(i32 / j32) }, "divide"}, + ErrorTest{"int64 0/0", func() { use(i64 / j64) }, "divide"}, + + ErrorTest{"int 1/0", func() { use(k / j) }, "divide"}, + ErrorTest{"int8 1/0", func() { use(k8 / j8) }, "divide"}, + ErrorTest{"int16 1/0", func() { use(k16 / j16) }, "divide"}, + ErrorTest{"int32 1/0", func() { use(k32 / j32) }, "divide"}, + ErrorTest{"int64 1/0", func() { use(k64 / j64) }, "divide"}, + + ErrorTest{"uint 0/0", func() { use(u / v) }, "divide"}, + ErrorTest{"uint8 0/0", func() { use(u8 / v8) }, "divide"}, + ErrorTest{"uint16 0/0", func() { use(u16 / v16) }, "divide"}, + ErrorTest{"uint32 0/0", func() { use(u32 / v32) }, "divide"}, + ErrorTest{"uint64 0/0", func() { use(u64 / v64) }, "divide"}, + ErrorTest{"uintptr 0/0", func() { use(up / vp) }, "divide"}, + + ErrorTest{"uint 1/0", func() { use(w / v) }, "divide"}, + ErrorTest{"uint8 1/0", func() { use(w8 / v8) }, "divide"}, + ErrorTest{"uint16 1/0", func() { use(w16 / v16) }, "divide"}, + ErrorTest{"uint32 1/0", func() { use(w32 / v32) }, "divide"}, + ErrorTest{"uint64 1/0", func() { use(w64 / v64) }, "divide"}, + ErrorTest{"uintptr 1/0", func() { use(wp / vp) }, "divide"}, + + // All float64ing divide by zero should not error. + ErrorTest{"float64 0/0", func() { use(f / g) }, ""}, + ErrorTest{"float32 0/0", func() { use(f32 / g32) }, ""}, + ErrorTest{"float64 0/0", func() { use(f64 / g64) }, ""}, + + ErrorTest{"float64 1/0", func() { use(h / g) }, ""}, + ErrorTest{"float32 1/0", func() { use(h32 / g32) }, ""}, + ErrorTest{"float64 1/0", func() { use(h64 / g64) }, ""}, + ErrorTest{"float64 inf/0", func() { use(inf / g64) }, ""}, + ErrorTest{"float64 -inf/0", func() { use(negInf / g64) }, ""}, + ErrorTest{"float64 nan/0", func() { use(nan / g64) }, ""}, // All complex divide by zero should not error. - ErrorTest{ "complex 0/0", func() { use(c/d) }, "", }, - ErrorTest{ "complex64 0/0", func() { use(c64/d64) }, "", }, - ErrorTest{ "complex128 0/0", func() { use(c128/d128) }, "", }, + ErrorTest{"complex 0/0", func() { use(c / d) }, ""}, + ErrorTest{"complex64 0/0", func() { use(c64 / d64) }, ""}, + ErrorTest{"complex128 0/0", func() { use(c128 / d128) }, ""}, - ErrorTest{ "complex 1/0", func() { use(e/d) }, "", }, - ErrorTest{ "complex64 1/0", func() { use(e64/d64) }, "", }, - ErrorTest{ "complex128 1/0", func() { use(e128/d128) }, "", }, + ErrorTest{"complex 1/0", func() { use(e / d) }, ""}, + ErrorTest{"complex64 1/0", func() { use(e64 / d64) }, ""}, + ErrorTest{"complex128 1/0", func() { use(e128 / d128) }, ""}, } func error(fn func()) (error string) { @@ -137,12 +171,12 @@ func error(fn func()) (error string) { return "" } -type FloatTest struct{ - f, g float64 - out float64 +type FloatTest struct { + f, g float64 + out float64 } -var floatTests = []FloatTest{ +var float64Tests = []FloatTest{ FloatTest{0, 0, nan}, FloatTest{nan, 0, nan}, FloatTest{inf, 0, inf}, @@ -194,8 +228,8 @@ func main() { } // At this point we know we don't error on the values we're testing - for _, t := range floatTests { - x := t.f/t.g + for _, t := range float64Tests { + x := t.f / t.g if !alike(x, t.out) { if !bad { bad = true |