require 'test/unit'
require 'logicagent'

BasicSocket.do_not_reverse_lookup = true

class TestGAgent < Test::Unit::TestCase

  def setup
    @agent = MyAgent.new
    @agent.send("reset graph")
    @agent.send("set save mode off")
  end

  # transitivity: a = b, b = c, therefore a = c
  def test_0
    actual = @agent.send("a = b")[0]
    assert_match(/Okay/, actual)
    actual = @agent.send("b = c")[0]
    assert_match(/Okay/, actual)
    actual = @agent.send("does a = c?")[0]
    assert_match(/Yes/, actual)
    actual = @agent.send("why does a = c?")[0]
    assert_match(/because: a = b, and b = c/, actual)
  end

  # transitivity: socrates is a man, all men are mortal, is Socrates mortal?
  def test_1
    actual = @agent.send("Socrates is a man.")[0]
    assert_match(/Okay/, actual)
    actual = @agent.send("a man is all men.")[0]
    assert_match(/Okay/, actual)
    actual = @agent.send("all men are mortal.")[0]
    assert_match(/Okay/, actual)
    actual = @agent.send("is Socrates mortal?")[0]
    assert_match(/Yes/, actual)
    actual = @agent.send("why is Socrates mortal?")[0]
    assert_match(/because: socrates is a man, and a man is all men, and all men are mortal/, actual)
  end

  # is Mercury solid? Mercury is not solid.
  def test_2
    actual = @agent.send("All metals are solid.")[0]
    assert_match(/^Okay/, actual)
    actual = @agent.send("Mercury is a metal.")[0]
    assert_match(/^Okay/, actual)
    actual = @agent.send("a metal is all metals.")[0]
    assert_match(/^Okay/, actual)
    actual = @agent.send("is MErcury solid?")[0]
    assert_match(/^Yes/, actual)
    actual = @agent.send("Why is Mercury solid?")[0]
    assert_match(/because: mercury is a metal, and a metal is all metals, and all metals are solid/, actual)
    actual = @agent.send("Mercury is not solid.")[0]
    assert_match(/contradicts/, actual)
    actual = @agent.send("remove edge all metals are solid")[0]
    assert_match(/^Okay/, actual)
    actual = @agent.send("what is MErcury?")[0]
    assert_match(/mercury is a metal/i, actual)
    assert_match(/[^(all metals)]/, actual)
    actual = @agent.send("is Mercury solid?")[0]
    assert_match(/no knowledge/, actual)
  end

  # save, load, reset
  def test_3
    actual = @agent.send("print graph")[0]
    assert_match(/empty/, actual)
    actual = @agent.send("a = b")[0]
    assert_match(/Okay/, actual)
    actual = @agent.send("save graph test.graph")[0]
    assert_match(/saved/, actual)
    actual = @agent.send("reset graph")[0]
    assert_match(/Okay/, actual)
    actual = @agent.send("y = z")[0]
    assert_match(/Okay/, actual)
    actual = @agent.send("print graph")[0]
    assert_match(/y = z/, actual)
    actual = @agent.send("load graph test.graph")[0]
    actual = @agent.send("print graph")[0]
    assert_match(/a = b/, actual)
    File.delete("test.graph")
  end

  # save mode
  def test_3b
    actual, s = @agent.send("what is the save mode?")
    assert_match(/\boff\b/, actual)
    actual, s = @agent.send("set save mode on")
    actual, s = @agent.send("what is the save mode?")
    assert_match(/\bon\b/, actual)
  end

  # reflexivity and symmetry: if a = b, a = a, b = b, and b = a
  def test_4
    actual = @agent.send("a = b")[0]
    assert_match(/Okay/, actual)
    actual = @agent.send("does a = a?")[0]
    assert_match(/Yes/, actual)
    actual = @agent.send("does b = b?")[0]
    assert_match(/Yes/, actual)
    actual = @agent.send("does a = b?")[0]
    assert_match(/Yes/, actual)
    actual = @agent.send("does b = a?")[0]
    assert_match(/Yes/, actual)
  end

  # multiple edges between vertices
  def test_5
    actual = @agent.send("birds are avians")[0]
    assert_match(/Okay/, actual)
    actual = @agent.send("birds = avians")[0]
    assert_match(/Okay/, actual)
    actual = @agent.send("are avians birds?")[0]
    #assert_match(/ no /, actual)
    actual = @agent.send("do avians = birds?")[0]
    assert_match(/Yes/, actual)
  end

  # Do ostriches have wings?
  def test_6
    actual = @agent.send("All birds have wings.")[0]
    assert_match(/Okay/, actual)
    actual = @agent.send("Ostriches are birds.")[0]
    assert_match(/Okay/, actual)
    actual = @agent.send("birds are all birds")[0]
    assert_match(/Okay/, actual)
    actual = @agent.send("Do ostriches have wings?")[0]
    assert_match(/Yes/, actual)

    actual = @agent.send("Friends have enemies.")[0]
    assert_match(/Okay/, actual)
    actual = @agent.send("John is a friend.")[0]
    assert_match(/Okay/, actual)
    actual = @agent.send("a friend is friends")[0]
    assert_match(/Okay/, actual)
    actual = @agent.send("Does John have enemies?")[0]
    assert_match(/Yes/, actual)
  end

  # Can all kings make mistakes?
  def test_7
    @agent.send("All men may make mistakes.")[0]
    @agent.send("All kings are men.")[0]
    @agent.send("men are all men")[0]
    actual = @agent.send("Can all kings make mistakes?")[0]
    assert_match(/Yes/, actual)
  end

  # Each person has two hands; a person is each person; what does a person have?
  def test_8
    @agent.send("Each person has two hands.")[0]
    @agent.send("a person is each person")[0]
    actual = @agent.send("What does each person have?")[0]
    expected = /two hands/
    assert_match(expected, actual)
    actual = @agent.send("What does a person have?")[0]
    assert_match(expected, actual)
  end

  # First few lines (without the counting part) of raphael_dialog.txt
  def test_9
    @agent.send("Every boy is a person.")
    @agent.send("A finger is part of a hand.")
    @agent.send("Each person has two hands.")
    actual = @agent.send("Does John have fingers?")[0]
    assert_match(/( no | nothing )/, actual)
    @agent.send("John is a boy.")
    @agent.send("a boy is every boy")
    @agent.send("a finger is fingers")
    @agent.send("a person is each person")
    @agent.send("two hands is a hand")
    actual = @agent.send("Does John have fingers?")[0]
    assert_match(/Yes/, actual)
  end

  # remove edge ___ has ___
  def test_10
    @agent.send("i have a cat")
    actual = @agent.send("remove 'i have a cat'")[0]
    assert_match(/Okay I have forgotten/, actual)
    actual = @agent.send("print graph")[0]
    assert_match(/The graph is empty./, actual)
  end

  # why does ___ have ___?
  def test_11
    @agent.send("I have a cat.")
    @agent.send("Cats have tails.")
    @agent.send("a cat is cats")
    @agent.send("tails is a tail")
    @agent.send("I is plural")
    @agent.send("i is plural")
    actual = @agent.send("Do I have a tail?")[0]
    assert_match(/Yes/, actual)
    actual = @agent.send("Why do I have a tail?")[0]
    expected = /because: i have a cat, and a cat is cats, and cats have tails, and tails are a tail/
    assert_match(expected, actual)
  end

  # a is a; what is a? is a a?
  def test_12
    @agent.send("a is a")
    actual = @agent.send("what is a?")[0]
    expected = "a is a"
    assert_equal(expected, actual)
    actual = @agent.send("is a a?")[0]
    assert_match(/Yes/, actual)
  end

  # a is a; why is a a?
  def test_13
    @agent.send("a is a")
    actual = @agent.send("why is a a?")[0]
    expected = /because/i
    assert_match(expected, actual)
    actual = @agent.send("is a a?")[0]
    assert_match(/Yes/, actual)
  end

  # a is b; is b b? why is b b?
  def test_14
    @agent.send("a is b")
    actual = @agent.send("is b b?")[0]
    assert_match(/Yes/, actual)
    actual = @agent.send("why is b b?")[0]
    assert_match(/because/i, actual)
  end

  # a = b; does a == b? etc.
  def test_15
    actual = @agent.send('a = b')[0]
    expected = /Okay, a = b./
    assert_match(expected, actual)

    actual = @agent.send('is a == b?')[0]
    expected = /Yes, a = b./
    assert_match(expected, actual)

    actual = @agent.send('does a == b?')[0]
    expected = /Yes, a = b./
    assert_match(expected, actual)

    actual = @agent.send('is a = b?')[0]
    expected = /Yes, a = b./
    assert_match(expected, actual)

    actual = @agent.send('does a = b?')[0]
    expected = /Yes, a = b./
    assert_match(expected, actual)

    actual = @agent.send('ostriches = avians')[0]
    expected = /Okay, ostriches = avians./
    assert_match(expected, actual)

    actual = @agent.send('do ostriches = avians?')[0]
    expected = /Yes, ostriches = avians./
    assert_match(expected, actual)

    actual = @agent.send('are avians == ostriches?')[0]
    expected = /Yes, avians = ostriches./
    assert_match(expected, actual)
  end

  # why is ___ ___? (___ not in graph)
  def test_16
    expected = /no knowledge/
    actual = @agent.send("why is Socrates mortal?")
    assert_match(expected, actual.to_s)
    
    @agent.send("Socrates is mortal")
    actual = @agent.send("why is mortal human?")
    assert_match(expected, actual.to_s)

    actual = @agent.send("why does a == b?")
    assert_match(expected, actual.to_s)

    actual = @agent.send("why do birds have wings?")
    assert_match(expected, actual.to_s)
  end

  # ___ means ___, ___ means the same as ___, ___ is the same as ___
  def test_17
    expected = /Okay/
    actual = @agent.send("man means a two-footed animal")
    assert_match(expected, actual.to_s)

    @agent.send("Socrates is a man")
    actual = @agent.send("a man means the same as man")
    assert_match(expected, actual.to_s)

    actual = @agent.send("is Socrates a two-footed animal?")
    assert_match(/yes/i, actual.to_s)

    actual = @agent.send("not being a man is the same as being a man")
    assert_match(/Okay/, actual.to_s)
  end

  # is "___" "___"? is ___ the same as ___? does ___ mean (the same as) ___? 
  # why is "___" "___"? why is ___ the same as ___? why does ___ mean ___?
  def test_18
    @agent.send('"being a man" means "not being a man"')

    actual = @agent.send('what does "being a man" mean?')
    assert_match(/not being a man/, actual.to_s)

    actual = @agent.send("is \"being a man\" \"not being a man\"?")
    assert_match(/Yes/, actual.to_s)

    actual = @agent.send("is \"being a man\" the same as \"not being a man\"?")
    assert_match(/Yes/, actual.to_s)

    actual = @agent.send("is being a man the same as not being a man?")
    assert_match(/Yes/, actual.to_s)

    actual = @agent.send("does \"being a man\" mean \"not being a man\"?")
    assert_match(/Yes/, actual.to_s)

    actual = @agent.send('why is "being a man" "not being a man"?')
    assert_match(/because/, actual.to_s)

    actual = @agent.send("why is being a man the same thing as not being a man?")
    assert_match(/because/, actual.to_s)

    actual = @agent.send('why does "being a man" mean "not being a man"?')
    assert_match(/because/, actual.to_s)
  end

  # The "mercury" dialog from the documentation.
  def test_19
     actual = @agent.send('All metals are solid.')
     expected = /Okay, All metals are solid./
     assert_match(expected, actual.to_s)

     actual = @agent.send('Mercury is a metal.')
     expected = /Okay, Mercury is a metal./
     assert_match(expected, actual.to_s)

     actual = @agent.send('a metal is all metals')
     expected = /Okay, a metal is all metals./
     assert_match(expected, actual.to_s)

     actual = @agent.send('is Mercury solid?')
     expected = /Yes, Mercury is solid./
     assert_match(expected, actual.to_s)

     actual = @agent.send('Mercury is not solid')
     expected = /That contradicts the information I have that Mercury is solid because: mercury is a metal, and a metal is all metals, and all metals are solid./
     assert_match(expected, actual.to_s)

     actual = @agent.send('forget "all metals are solid."')
     expected = /Okay I have forgotten all metals are solid./
     assert_match(expected, actual.to_s)

     actual = @agent.send('is Mercury solid?')
     expected = /I have no knowledge that Mercury is solid./
     assert_match(expected, actual.to_s)
  end

  # names
  def test_20
    actual, s = @agent.send("joe is a name")
    assert_match(/Okay\b/, actual)
    actual, s = @agent.send("joe: a is b")
    assert_match(/Okay\b/, actual)
    actual, s = @agent.send("what is a?")
    assert_match(/\bb\b/, actual)

    actual, s = @agent.send("what are the names?")
    assert_match(/\bjoe\b/, actual)

    actual, s = @agent.send("joe is not a name")
    assert_match(/Okay/, actual)

    actual, s = @agent.send("what are the names?")
    assert_match(//, actual)
  end

  # read file
  def test_21
    actual, s = @agent.send("read highest.txt")
    assert_match(/Okay/, actual)

    actual, s = @agent.send("what is something you find at the beach?")
    assert_match(/sand/, actual)

    #actual, s = @agent.send("read openmind\\assertions-1-1")
    #assert_match(/Okay/, actual)

    actual, s = @agent.send("reset graph")
    #actual, s = @agent.send("read openmind/highest.txt")
    actual, s = @agent.send("read highest.txt")
    assert_match(/Okay/, actual)
    actual, s = @agent.send("how many facts?")
    assert_match(/164/, actual)

    actual, s = @agent.send("what was the last file read")
    assert_match(/highest.txt/, actual)

  end

  # birds flying
  def test_22
    actual, s = @agent.send("a bird can fly")
    actual, s = @agent.send("can a bird fly?")
    assert_match(/Yes/, actual)

    actual, s = @agent.send("planes fly")
    actual, s = @agent.send("can planes fly?")
    assert_match(/Yes/, actual)
  end

  # is "A recommends gold" true?
  def test_23
    actual, s = @agent.send("A recommends gold")
    actual, s = @agent.send("B recommends gold")
    actual, s = @agent.send("Does A recommend Gold?")
    assert_match(/Yes/, actual)
    actual, s = @agent.send("is \"B recommends gold\" true?")
    ###assert_match(/Yes/, actual)
    actual, s = @agent.send("is \"A recommends gold\" true?")
    ###assert_match(/Yes/, actual)
  end

  # X eats Y, does X eat Y?, why does X eat Y
  def test_24
    actual, s = @agent.send("bears eat fish")
    actual, s = @agent.send("bears eat foxes")
    actual, s = @agent.send("deers eat grass")
    actual, s = @agent.send("deer eat grass")
    actual, s = @agent.send("a deer eats grass")

    actual, s = @agent.send("a bear is an animal")
    actual, s = @agent.send("a fish is an animal")
    actual, s = @agent.send("a fox is an animal")
    actual, s = @agent.send("a deer is an animal")
    actual, s = @agent.send("grass is a plant")

    # Ex. 37 from Section 1.5 of "Mathematical Structures for Computer Science"
    actual, s = @agent.send("is a bear an animal?")
    assert_match(/Yes/i, actual)
    actual, s = @agent.send("does a deer eat grass?")
    assert_match(/Yes/i, actual)
    actual, s = @agent.send("do deer eat grass?")
    assert_match(/Yes/i, actual)
    actual, s = @agent.send("does a bear eat a rabbit?")
    assert_match(/no knowledge/i, actual)

    # Ex. 38
    actual, s = @agent.send("what do bears eat?")
    assert_match(/fish.*fox/im, actual)
    actual, s = @agent.send("what does a bear eat?")
    assert_match(/don't know/, actual)
    #actual, s = @agent.send("a bear is bears")
    actual, s = @agent.send("a bear eats fish")
    actual, s = @agent.send("a bear eats foxes")
    actual, s = @agent.send("what does a bear eat?")
    assert_match(/fish.*fox/im, actual)

    actual, s = @agent.send("what eats grass?")
    assert_match(/deer/i, actual)

    actual, s = @agent.send("cows eat grass")
    actual, s = @agent.send("what eats grass?")
    assert_match(/deer.*cows/im, actual)

    actual, s = @agent.send("a plant is grass")
    actual, s = @agent.send("plants are a plant")
    actual, s = @agent.send("what eats plants?")
    assert_match(/deer/i, actual)

    actual, s = @agent.send("x is a prey if it is an animal that is eaten.")

    actual, s = @agent.send("which animals are prey?")
    #assert_match(/fish.*fox/im, actual)

  end

  # Question from the national teachers' examination, given in 1992
  # by the Educational Testing Service, cited in "Logic Made Easy", 
  # by Deborah Bennett, page 17.
  def test_25
    actual, s = @agent.send("All education majors student teach.")
    assert_match(/Okay/, actual)

    actual, s = @agent.send("Some education majors have double majors.")
    assert_match(/Okay/, actual)

    actual, s = @agent.send("Some mathematics students are education majors.")
    assert_match(/Okay/, actual)

    actual, s = @agent.send("Do some of those with double majors student teach?")
    assert_match(/no knowledge/, actual)

    actual, s = @agent.send("double majors is had by some education majors")
    assert_match(/Okay/, actual)

    actual, s = @agent.send("some education majors are all education majors")
    assert_match(/Okay/, actual)

    actual, s = @agent.send("some of those with double majors is double majors")
    assert_match(/Okay/, actual)

    actual, s = @agent.send("Do some of those with double majors student teach?")
    assert_match(/Yes/, actual) 

    actual, s = @agent.send("Why do some of those with double majors student teach?")
    assert_match(/because.*are.*are had by.*are.*student teach/m, actual)
  end 

  # Lunar system example (Intro. to Art. Int., Charniak and McDermott, p.2)
  def test_lunar
    actual, s = @agent.send("s10020 contains chromite")
    actual, s = @agent.send("s10045 contains chromite")
    actual, s = @agent.send("s10084 contains chromite")
    actual, s = @agent.send("what contains chromite?")
    assert_match(/s10020/, actual)
    assert_match(/s10045/, actual)
    assert_match(/s10084/, actual)

    actual, s = @agent.send("How many samples contain chromite?")
    assert_match(/3/, actual)

    actual, s = @agent.send("What are those samples?")
    assert_match(/s10020/, actual)
    assert_match(/s10045/, actual)
    assert_match(/s10084/, actual)
  end

  def test_link
    actual, s = @agent.send("yahoo is http://yahoo.com")
    actual, s = @agent.send("what is yahoo?")
    assert_match(/http\:\/\//, actual)

    actual, s = @agent.send("west end blues is http://www.youtube.com/watch?v=f5Hbh_-IRs8")
    actual, s = @agent.send("what is west end blues?")
    assert_match(/#{Regexp.escape("http://www.youtube.com/watch?v=f5Hbh_-IRs8")}/, actual)
  end

  def test_when_was
    actual, s = @agent.send("the pliocene was from 2-10 million years ago.")
    actual, s = @agent.send("when was the pliocene?")
    assert_match(/2-10 million years ago/, actual)

    actual, s = @agent.send("the blah was x years ago.")
    actual, s = @agent.send("the blah == the blah period")
    actual, s = @agent.send("when was the blah period?")
    assert_match(/is x years ago/, actual)
  end

  def test_funnier_than
    actual, s = @agent.send("seinfeld is funnier than frasier")
    actual, s = @agent.send("frasier is funnier than charlie sheen")
    actual, s = @agent.send("charlie sheen = sheen")
    actual, s = @agent.send("is seinfeld funnier than sheen?")
    assert_match(/yes/i, actual)

    actual, s = @agent.send("why is seinfeld funnier than charlie sheen?")
    assert_match(/because/, actual)
  end
  
  def test_greater_than
    actual, s = @agent.send("10 > 1")
    assert_match(/true|yes/i, actual)

    actual, s = @agent.send("is 10 > 4?")
    assert_match(/true|yes/i, actual)

    actual, s = @agent.send("is 10 greater than 5?")
    assert_match(/no|false/i, actual)

    actual, s = @agent.send("\"is greater than\" == \">\"")
    actual, s = @agent.send("is 10 greater than 5?")
    assert_match(/true|yes/i, actual)

    actual, s = @agent.send("is 100 greater than 1001?")
    assert_match(/false|no/i, actual)

    actual, s = @agent.send("which is greater, 25 or 37?")
    assert_match(/37 is greater/i, actual)
  end

end # class