# Copyright 2005-2007 Kevin Reid, under the terms of the MIT X license
# found at http://www.opensource.org/licenses/mit-license.html ................

XXX very incomplete tests - the first group originally written just to test the print value of a closed resolver
  
  ? def [p, r] := Ref.promise()
  # value: [<Promise>, <Resolver>]
  
  ? r.isDone()
  # value: false
  
  ? p.foo("bar", null)
  # problem: not synchronously callable: <Promise>.foo("bar", null)
  
  ? [r.resolve(1)]
  # value: [null]
  
  ? r
  # value: <Closed Resolver>
  
  ? r.isDone()
  # value: true
  
  ? p
  # value: 1

resolver#resolve

  ? def [p, r] := Ref.promise()
  # value: [<Promise>, <Resolver>]
  
  ? r.isDone()
  # value: false
  
  ? [r.resolve(1), p, r]
  # value: [null, 1, <Closed Resolver>]

  ? r.isDone()
  # value: true
  
  ? r.resolve(2)
  # problem: this resolver's ref has already been resolved, therefore cannot be resolved to 2
  
  ? [p, r]
  # value: [1, <Closed Resolver>]
  
  ? r.isDone()
  # value: true

resolver#resolveRace

  ? def [p, r] := Ref.promise()
  # value: [<Promise>, <Resolver>]
  
  ? r.isDone()
  # value: false
  
  ? [r.resolveRace(1), p, r]
  # value: [true, 1, <Closed Resolver>]

  ? r.isDone()
  # value: true
  
  ? [r.resolveRace(2), p, r]
  # value: [false, 1, <Closed Resolver>]
  
  ? r.isDone()
  # value: true
  
Ref

  ? Ref
  # value: <Ref>

  ? Ref :DeepFrozen
  # value: <Ref>
  
 resolution (shortens references; transparent.)
 
  ? Ref.resolution("null")
  # value: "null"
 
  ? Ref.resolution(Ref.broken("bang"))
  # value: <ref broken by problem: bang>
 
  ? Ref.resolution(def p := Ref.promise()[0]) == p
  # value: true
 
 broken
  
  ? Ref.broken("bang")
  # value: <ref broken by problem: bang>
  
  ? Ref.broken(def _ {to __conformTo(g) :any {return g.coerce("biff", throw)}})
  # value: <ref broken by problem: biff>
  
  ? Ref.broken(null)
  # problem: the Null null doesn't coerce to a Throwable

 isNear

  ? Ref.isNear(1)
  # value: true
  
  ? Ref.isNear(Ref.promise()[0])
  # value: false

  ? Ref.isNear(Ref.promise())
  # value: true

  ? Ref.isNear(Ref.broken("biff"))
  # value: false

  XXX isNear with far refs

 isSettled
 
  ? Ref.isSettled(1)
  # value: true
 
  ? Ref.isSettled([1])
  # value: true

  ? Ref.isSettled(Ref.promise()[0])
  # value: false

  ? Ref.isSettled(def settled_test_pair := Ref.promise())
  # value: false
  
  ? settled_test_pair[1].resolve(2)

  ? Ref.isSettled(settled_test_pair)
  # value: true
  
  ? Ref.isSettled(Ref.broken("biff"))
  # value: true
  
 isFar
 
  XXX test with actual Far ref
  
  ? Ref.isFar(1)
  # value: false
    
  ? Ref.isFar(245398378954763192874789237489237483234532523463467)
  # value: false
  
  ? Ref.isFar({def x; x})
  # value: false
  
  ? Ref.isFar(def y {})
  # value: false
  
  ? Ref.isFar(Ref.broken("you'll never know"))
  # value: false

 isResolved

  ? Ref.isResolved("idea")
  # value: true

  ? Ref.isResolved(Ref.broken("nope"))
  # value: true

  ? Ref.isResolved(Ref.promise()[0])
  # value: false
  
 fulfillment

  ? Ref.fulfillment("null")
  # value: "null"

  ? Ref.fulfillment(Ref.broken("bang"))
  # problem: bang
  
  ? Ref.fulfillment(Ref.promise()[0])
  # problem: not resolved (Ref#fulfillment)

 optProblem and matching

  ? [Ref.optProblem('r')]
  # value: [null]

  ? Ref.optProblem(Ref.broken("expected"))
  # value: problem: expected

  ? [Ref.optProblem(Ref.promise()[0])]
  # value: [null]
  
  ? pragma.enable("trinary-define")
  ? pragma.enable("call-pattern")
  
  ? escape e { def Ref.broken(p) exit e := 'r'; p }
  # value: problem: 'r' is not broken
  
  ? escape e { def Ref.broken(p) exit e := Ref.broken("expected"); [p] }
  # value: [problem: expected]
  
  ? escape e { def Ref.broken(p) exit e := Ref.promise()[0]; p }
  # value: problem: <Promise> is not broken
  
 isEventual

  ? Ref.isEventual("idea")
  # value: false

  ? Ref.isEventual(Ref.broken("nope"))
  # value: false

  ? Ref.isEventual(Ref.promise()[0])
  # value: true

 isSelfish
 
  ? Ref.isSelfish("a")
  # value: false
  
  ? Ref.isSelfish('a')
  # value: false
  
  ? Ref.isSelfish(['a'])
  # value: false
  
  ? Ref.isSelfish(def _ {})
  # value: true
  
  ? Ref.isSelfish(Ref)
  # value: true
  
  ? Ref.isSelfish(interp)
  # value: true

 optSealedDispatch
 
  For near refs, Ref#optSealedDispatch acts exactly like calling optSealedDispatch on the ref. For non-near refs, it may provide sealed-dispatch communication with the underlying implementation of that ref; see proxy.updoc for tests of this behavior.
  
  ? [Ref.optSealedDispatch(def _ { to __optSealedDispatch(x) :any {return x}}, 1)]
  # value: [1]

  ? [Ref.optSealedDispatch(def _ {}, 1)]
  # value: [null]
  
  ? [Ref.optSealedDispatch(Ref.broken("optSealedDispatch test broken"), 1)]
  # value: [null]

  ? [Ref.optSealedDispatch(Ref.promise()[0], 1)]
  # value: [null]
  
 whenResolved
 
  Checking that __whenMoreResolved is sent send-only.
  ? Ref.whenResolved(
  >   <elib:ref.makeProxy>(def handler match msg { print(msg) },
  >                        Ref.promise()[0], false),
  >   fn _ {})
  > null
  # stdout: ["handleSendOnly", ["__whenMoreResolved", [<safeWhenResolvedReactor>]]]

 whenResolvedOnly
 
  whenResolvedOnly, unlike whenResolved, does not collect the result of the reactor, and so can sendOnly to it.

  ? Ref.whenResolvedOnly(
  >   1,
  >   <elib:ref.makeProxy>(def handler match msg { print(msg) },
  >                        Ref.promise()[0], true))
  # stdout: ["handleSendOnly", ["run", [1]]]
  
  XXX write tests for waiting behavior
  XXX the above two tests look similar but do completely different things; this should be clarified and other tests written

Bugfix test: promise ref not propagating opt-problem correctly

  ? def [p, r] := Ref.promise()
  # value: [<Promise>, <Resolver>]
  
  ? r.smash("boink")
  
  ? Ref.optProblem(p)
  # value: problem: boink

Broken reference details

  XXX this updoc script is ordering-fragile

  ? Ref.broken("biff").__whenMoreResolved(print) 
  # problem: biff
  
  # stdout: <ref broken by problem: biff>

  ? Ref.broken("biff").__whenBroken(print) 
  # problem: biff
  
  # stdout: <ref broken by problem: biff>

  XXX these reveal that <BROKEN> <- anything *immediately* produces a broken reference, rather than a promise. This matches Java-E, but is it *right*?

  ? Ref.broken("biff") <- __whenMoreResolved(print) 
  # value: <ref broken by problem: biff>
  
  # stdout: <ref broken by problem: biff>

  ? Ref.broken("biff") <- __whenBroken(print) 
  # value: <ref broken by problem: biff>
  
  # stdout: <ref broken by problem: biff>

  Checking that the WMR reactor is invoked sendOnly.
  ? Ref.broken("biff") <- __whenMoreResolved(
  >   <elib:ref.makeProxy>(def handler match msg { print(msg) },
  >                        Ref.promise()[0], false)); null
  # stdout: ["handleSendOnly", ["run", [<ref broken by problem: biff>]]]
  
  Checking that sendOnly on a broken reference works.
  ? E.sendOnly(Ref.broken("biff"), "__whenBroken", [print])
  # stdout: <ref broken by problem: biff>
  

Checking that a chain of promises does not accumulate a chain of resolved forwarders.

  ? def [p, var r] := Ref.promise()
  # value: [<Promise>, <Resolver>]
  
  ? for _ in 1..20 {
  >   def [q, s] := Ref.promise()
  >   r.resolve(q)
  >   r := s
  > }
  > r.resolve(true)
  
  checking our assumption
  ? lisp["CL", "TYPE-OF"].getFunction()(p)
  # value: RESOLVED-REF
  
  checking the actual desired condition
  ? lisp["CL", "TYPE-OF"].getFunction()(
  >   lisp["CL", "SLOT-VALUE"].getFunction()(p, lisp["E.ELIB", "TARGET"].asSymbol()))
  # value: E-BOOLEAN