def test_Triangle():
    A = rand_pt()
    B = rand_pt()
    C = rand_pt()
    t = Triangle(A, B, C)
    O = t.centre_cercle_circonscrit
    assertAlmostEqual(Segment(O, A).longueur, Segment(O, C).longueur)

def test_Glisseur_segment():
    A = rand_pt()
    B = rand_pt()
    s = Segment(A, B)
    M = Glisseur_segment(s)
    assert(M in s)
    M.k = 0
    assertEqual(M.k, 0)
    assertAlmostEqual(M.coordonnees, A.coordonnees)
    P = Point(*M.coordonnees)
    M.k = 1
    assertEqual(M.k, 1)
    assertAlmostEqual(M.coordonnees, B.coordonnees)
    M.k = 2
    assertEqual(M.k, 1) # 0<=k<=1 pour un segment
    assert(M in s)
    M.k = -1
    assertEqual(M.k, 0) # 0<=k<=1 pour un segment
    assert(M in s)
    M.k = 1
    Q = Point(*M.coordonnees)
    assertAlmostEqual(Droite(P, Q).equation_reduite, s.equation_reduite)
    M.k = 1.7
    M(*M.coordonnees)
    assertAlmostEqual(M.k, 1)

def test_Quadrilatere():
    A = rand_pt()
    B = rand_pt()
    C = rand_pt()
    D = rand_pt()
    p = Quadrilatere(A, B, C, D)
    assertAlmostEqual(p.centre.coordonnees, Barycentre(A, B, C, D).coordonnees)

def test_Carre_centre():
    O = rand_pt()
    M = rand_pt()
    p = Carre_centre(O, M)
    assert(p.centre.existe and p.centre is O)
    assert(len(p.cotes) == 4)
    assertAlmostEqual(p.aire,  p.cotes[0].longueur**2)

def test_Orthocentre():
    A, B, C = rand_pt(), rand_pt(), rand_pt()
    p = Polygone(A, B, C)
    H = Orthocentre(p)
    assert(Droite(A, H).perpendiculaire(Droite(B, C)))
    assert(Droite(B, H).perpendiculaire(Droite(A, C)))
    assert(Droite(C, H).perpendiculaire(Droite(B, A)))

def test_Parallelogramme():
    A = rand_pt()
    B = rand_pt()
    C = rand_pt()
    p = Parallelogramme(A, B, C)
    D = p.sommets[3]
    assertEqual(Vecteur(A, B), Vecteur(D, C))

def test_Pentagone():
    A = rand_pt()
    B = rand_pt()
    C = rand_pt()
    D = rand_pt()
    E = rand_pt()
    p = Pentagone(A, B, C, D, E)
    assertAlmostEqual(p.centre.coordonnees, Barycentre(A, B, C, D, E).coordonnees)

def test_Point_equidistant():
    A = rand_pt()
    B = rand_pt()
    C = rand_pt()
    P = Point_equidistant(A, B, C)
    assertAlmostEqual(Segment(A, P).longueur, Segment(B, P).longueur)
    assertAlmostEqual(Segment(A, P).longueur, Segment(C, P).longueur)
    assert(P in Mediatrice(A, B))

def test_Glisseur_arc_cercle():
    A = rand_pt()
    B = rand_pt()
    C = rand_pt()
    a = Arc_cercle(A, B, C)
    M = Glisseur_arc_cercle(a)
    assert(M in a)
    O = a.centre
    M.coordonnees = O.coordonnees

def test_Triangle_equilateral_centre():
    O = rand_pt()
    M = rand_pt()
    p = Triangle_equilateral_centre(O, M)
    assert(p.centre.existe and p.centre is O)
    assert(p.centre_cercle_circonscrit.existe)
    assert(p.centre_cercle_inscrit.existe)
    assert(p.orthocentre.existe)
    assert p.orthocentre.confondu(p.centre, p.centre_cercle_circonscrit, p.centre_cercle_inscrit)

def test_Label_point():
    A = rand_pt()
    B = rand_pt()
    A.label("Position de l'hirondelle d'Afrique.")
    B.label(u"Position de l'hirondelle européenne.")
    assert(A.label() == "Position de l'hirondelle d'Afrique.")
    assert(B.label() == u"Position de l'hirondelle européenne.")
    A.style(legende = NOM)
    assert(A.label() == "")

def test_Triangle_equilateral():
    O = rand_pt()
    M = rand_pt()
    p = Triangle_equilateral(O, M)
    assert(p.centre.existe)
    assert(p.centre_cercle_circonscrit.existe)
    assert(p.centre_cercle_inscrit.existe)
    assert(p.orthocentre.existe)
    assert(p.orthocentre == p.centre == p.centre_cercle_circonscrit == p.centre_cercle_inscrit)

def test_Centre_cercle_inscrit():
    A, B, C = rand_pt(), rand_pt(), rand_pt()
    p = Polygone(A, B, C)
    I = Centre_cercle_inscrit(p)
    P = Projete_segment(I, Segment(B, C))
    Q = Projete_segment(I, Segment(A, C))
    R = Projete_segment(I, Segment(A, B))
    c = Cercle(I, P)
    assert(P in c and Q in c and R in c)

def test_Losange():
    A = rand_pt()
    B = rand_pt()
    l = Losange(A, B)
    M, N, O, P = l.sommets
    diagonale1 = Droite(M, O)
    diagonale2 = Droite(N, P)
    assert(diagonale1.perpendiculaire(diagonale2))
    cote = Droite(M, N)
    cote_oppose = Droite(O, P)
    assert(cote.parallele(cote_oppose))

def test_Centre_gravite():
    A = rand_pt()
    B = rand_pt()
    C = rand_pt()
    I = Milieu(B, C)
    J = Milieu(A, C)
    K = Milieu(A, B)
    G = Centre_gravite(Triangle(A, B, C))
    assertAlmostEqual(Segment(A, G).longueur, 2*Segment(I, G).longueur)
    assertAlmostEqual(Segment(B, G).longueur, 2*Segment(J, G).longueur)
    assertAlmostEqual(Segment(C, G).longueur, 2*Segment(K, G).longueur)

def test_Rectangle():
    A = rand_pt()
    B = rand_pt()
    r = Rectangle(A, B)
    M, N, O, P = r.sommets
    diagonale1 = Segment(M, O)
    diagonale2 = Segment(N, P)
    assertAlmostEqual(diagonale1.longueur, diagonale2.longueur)
    cote = Droite(M, N)
    cote_oppose = Droite(O, P)
    assert(cote.parallele(cote_oppose))

def test_Triangle_isocele():
    A = rand_pt()
    B = rand_pt()
    tri = Triangle_isocele(A, B, 2*pi/13)
    C = tri.point3
    a = Angle(B, A, C)
    assertAlmostEqual(a.radian, 2*pi/13)
    assertAlmostEqual(Segment(A, B).longueur, Segment(A, C).longueur)
    t1 = Triangle_isocele((0, 0), (1, 1), u'90°')
    assertAlmostEqual(t1.point3.xy, (-1, 1))
    t2 = Triangle_isocele((0, 0), (2, 0), pi/3)
    assertAlmostEqual(t2.point3.xy, (2*cos(pi/3), 2*sin(pi/3)))

def test_Nuage():
    A = rand_pt()
    B = rand_pt()
    C = rand_pt()
    D = rand_pt()
    while D in (A, B, C):
        D = rand_pt()
    n = Nuage(A, B, C)
    assert n.points == (A, B, C)
    assert A in n
    assert B in n
    assert C in n
    assert D not in n

def test_polygones_et_representants_de_vecteurs():
    f = Feuille()
    f.objets.A = A = rand_pt()
    f.objets.B = B = rand_pt()
    f.objets.C = C = rand_pt()
    f.objets.p = Parallelogramme(A, B, C)
    f.objets.S1.renommer("D")
    s = repr(f.objets.p)
    del f.objets.p
    assert("D" not in f.objets)
    exec("p=" + s, f.objets)
    assert("D" in f.objets)
    assert(f.objets.D is f.objets.p.sommets[3])

def test_Polygone_regulier():
    O = rand_pt()
    M = rand_pt()
    p = Polygone_regulier(O, M, 15)
    assert(len(p.cotes) == 15)
    assert(p.centre in Mediatrice(O, M))
    for i in xrange(15):
        assertAlmostEqual(Segment(p.sommets[i%15], p.sommets[(i+1)%15]).longueur, Segment(p.sommets[(i+2)%15], p.sommets[(i+3)%15]).longueur)
    p = Polygone_regulier(O, M, 3)
    assert(isinstance(p,  Triangle))
    p = Polygone_regulier(O, M, 4)
    assert(isinstance(p,  Quadrilatere))
    # Test de régression :
    # la taille de str(p.points) croissait exponentiellement.
    assert(len(str(p.points)) < 30000)