describe "A suite", ->
  it "contains spec with an expectation", ->
    expect(true).toBe true

describe "A suite is just a function", ->
  it "and so is a spec", ->
    a = true
    expect(a).toBe true

describe "The 'tobe' matcher compares with ===", ->
  it "and has a positive case", ->
    expect(true).toBe true

  it "and can have a negative case", ->
    expect(false).not.toBe true

describe "Included matchers:", ->
  it "The 'toBe' matcher compares with ===", ->
    a = 12
    b = a
    expect(a).toBe b
    expect(a).not.toBe null

  describe "The 'toEqual' matcher", ->
    it "works for simple literals and variables", ->
      a = 12
      expect(a).toEqual 12
    it "should work for objects", ->
      foo =
        a: 12
        b: 34
      bar =
        a: 12
        b: 34
      expect(foo).toEqual bar

  it "The 'toMatch' matcher is for regular expressions", ->
    message = 'foo bar baz'
    expect(message).toMatch /bar/
    expect(message).toMatch 'bar'
    expect(message).not.toMatch /quux/

  it "The 'toBeDefined' matcher compares against 'undefined'", ->
    a =
      foo: 'foo'
    expect(a.foo).toBeDefined()
    expect(a.bar).not.toBeDefined()

  it "The 'toBeUndefined' matcher compares against 'undefined'", ->
    a =
      foo: 'foo'
    expect(a.foo).not.toBeUndefined()
    expect(a.bar).toBeUndefined()

  it "The 'toBeNull' matcher compares against null", ->
    a = null
    foo = 'foo'
    expect(null).toBeNull()
    expect(a).toBeNull()
    expect(foo).not.toBeNull()

  it "The 'toBeTruthy' matcher is for boolean casting testing", ->
    a = false
    foo = 'foo'
    expect(foo).toBeTruthy()
    expect(a).not.toBeTruthy()

  it "The 'toBeFalsy' matcher is for boolean casting testing", ->
    a = false
    foo = 'foo'
    expect(a).toBeFalsy()
    expect(foo).not.toBeFalsy()

  it "The 'toContain' matcher is for finding an item in an Array", ->
    a = ['foo', 'bar', 'baz']
    expect(a).toContain 'bar'
    expect(a).not.toContain 'quux'

  it "The 'toBeLessThan' matcher is for mathematical comparisons", ->
    pi = 3.1415926
    e = 2.78
    expect(e).toBeLessThan pi
    expect(pi).not.toBeLessThan e

  it "The 'toBeGreaterThan' is for mathematical comparisons", ->
    pi = 3.1415926
    e = 2.78
    expect(pi).toBeGreaterThan e
    expect(e).not.toBeGreaterThan pi

  it "The 'toBeCloseTo' matcher is for precision math comparison", ->
    # Matcher that checks that the expected item is equal to the actual item
    # up to a given level of decimal precision (default 2).
    pi = 3.1415926
    e = 2.78
    expect(pi).not.toBeCloseTo e, 2
    expect(pi).toBeCloseTo e, 0

  it "The 'toThrow' matcher is for testing if a function throws an exception", ->
    foo = -> 1 + 2
    bar = (a) -> a + 1
    expect(foo).not.toThrow()
    expect(bar).not.toThrow()

describe "A spec", ->
  it "is just a function, so it can contain any code", ->
    foo = 0
    foo += 1
    expect(foo).toEqual 1

  it "can have more than one expectation", ->
    foo = 0
    foo += 1
    expect(foo).toEqual 1
    expect(true).toEqual true

describe "A spec (with setup and tear-down)", ->
  # Here is the same set of specs written a little differently.
  # The variable under test is defined at the top-level scope
  # - the describe block - and initialization code is
  # moved into a beforeEach function.
  # The afterEach function resets the variable before continuing.
  foo = null
  beforeEach ->
    foo = 0
    foo += 1
  afterEach ->
    foo = 0
  it "is just a function, so it can contain any code", ->
    expect(foo).toEqual 1
  it "can have more than one expectation", ->
    expect(foo).toEqual 1
    expect(true).toEqual true

describe "A spec", ->
  # Calls to describe can be nested, with specs defined at any level.
  # This allows a suite to be composed as a tree of functions.
  # Before a spec is executed,
  # Jasmine walks down the tree executing each beforeEach function in order.
  # After the spec is executed, Jasmine walks through the afterEach functions similarly.
  foo = null
  beforeEach ->
    foo = 0
    foo += 1
  afterEach ->
    foo = 0
  it "is just a function, so it can contain any code", ->
    expect(foo).toEqual 1
  it "can have more than one expectation", ->
    expect(foo).toEqual 1
    expect(true).toEqual true
  describe "nested inside a second describe", ->
    bar = null
    beforeEach ->
      bar = 1
    it "can reference both scopes as needed", ->
      expect(foo).toEqual bar

xdescribe "A spec", ->
  # Suites and specs can be disabled with the xdescribe and xit functions, respectively.
  # These suites and specs are skipped when run
  # and thus their results will not appear in the results.
  foo = null
  beforeEach ->
    foo = 0
    foo += 1
  xit "is just a function, so it can contain any code", ->
    expect(foo).toEqual 1

describe "A spy", ->
  # Jasmine’s test doubles are called spies.
  # A spy can stub any function and tracks calls to it and all arguments.
  foo = null
  bar = null
  beforeEach ->
    foo =
      setBar: (value) ->
        bar = value

    spyOn foo, 'setBar'

    foo.setBar 123
    foo.setBar 456, 'another param'

  it "tracks that the spy was called", ->
    expect(foo.setBar).toHaveBeenCalled()

  it "tracks its number of calls", ->
    expect(foo.setBar.calls.length).toEqual 2

  it "tracks all the arguments of its calls", ->
    expect(foo.setBar).toHaveBeenCalledWith 123
    expect(foo.setBar).toHaveBeenCalledWith 456, 'another param'

  it "allows access to the most recent call", ->
    expect(foo.setBar.mostRecentCall.args[0]).toEqual 456

  it "allows access to other calls", ->
    expect(foo.setBar.calls[0].args[0]).toEqual 123

  it "stops all execution on a function", ->
    expect(bar).toBeNull()
ブログやってます：PAPA-tronix !