Esempio n. 1
0
void test_restriccion() {
    Rest rojo("rojo");
    Rest amarillo("Amarillo");
    Rest verde("VERDE");
    
    Rest res1((rojo.OR(amarillo)).AND(verde.NOT()));
    
    
//    Rest res1("(rojo | Amarillo) & !VERDE");
    Conj<Caracteristica> carac;
    carac.Agregar("Amarillo");
    
//    ASSERT(res1 -> Verifica(carac));
    ASSERT(res1.Verifica(carac));
    
    Rest coso("Coso");
    Rest noCoso(coso.NOT());
    Rest res2 = res1.AND(noCoso);
    
    carac.Agregar("Coso");
    ASSERT(res1.Verifica(carac));
    ASSERT(!res2.Verifica(carac));
    
    Conj<Caracteristica> carac2;
    carac2.Agregar("Coso");
    Rest siCoso = noCoso.NOT();
    ASSERT(siCoso.Verifica(carac2));
}
Esempio n. 2
0
void test_inspeccion_con_empate() {
    Conj<Estacion> es;
    es.Agregar("Belgrano");
    es.Agregar("Retiro");
    Driver d(es);
    d.AgregarSenda("Belgrano","Retiro","ca");

    Conj<Caracteristica> cs1;
    cs1.Agregar("cb");
    d.Entrar(cs1,"Belgrano");
    d.Entrar(cs1,"Belgrano");
    d.Entrar(cs1,"Belgrano");
    d.Entrar(cs1,"Retiro");
    ASSERT_EQ(d.CantidadRobotsActivos(),4);
    d.Mover(0, "Retiro");
    d.Mover(1, "Retiro");
    d.Mover(2, "Retiro");
    d.Inspeccion("Retiro"); // debe volar un solo RUR del conj {0,1,2}

    ASSERT_EQ(d.CantidadRobotsActivos(),3);

    infoRobots info = getDatosRobotsActivos(d);
    // Chequeo que los que quedan están ok
    // Alguno de los primeros RURs tuvo que desaparecer
    ASSERT(!(info.estaciones.Definido(0) && info.estaciones.Definido(1) && info.estaciones.Definido(2)));
    ASSERT_EQ(info.estaciones.Significado(3),"Retiro");
    ASSERT_EQ(info.infracciones.Significado(3),0);
}
Esempio n. 3
0
void test_el_mas_infractor() {
    Conj<Estacion> es;
    es.Agregar("Belgrano");
    es.Agregar("Retiro");
    Driver d(es);
    d.AgregarSenda("Belgrano","Retiro","ca");

    Conj<Caracteristica> cs1;
    cs1.Agregar("cb");
    d.Entrar(cs1,"Belgrano");
    d.Entrar(cs1,"Belgrano");
    d.Entrar(cs1,"Belgrano");
    d.Entrar(cs1,"Retiro");
    ASSERT_EQ(d.CantidadRobotsActivos(),4);
    d.Mover(0, "Retiro");
    d.Mover(1, "Retiro");
    d.Mover(2, "Retiro");
    d.Mover(0, "Belgrano");
    d.Mover(1, "Belgrano");

    Conj<RUR> peores; // {0,1} con 2 infracciones
    peores.Agregar(0);
    peores.Agregar(1);

    ASSERT(peores.Pertenece(d.ElMasInfractor()));

    d.Mover(0,"Retiro"); // Ahora el RUR 0 es el más infractor
    ASSERT_EQ(d.ElMasInfractor(),0);
}
Esempio n. 4
0
void test_el_mas_infractor_e_inspeccion() {
    Conj<Estacion> es;
    es.Agregar("Belgrano");
    es.Agregar("Retiro");
    Driver d(es);
    d.AgregarSenda("Belgrano","Retiro","ca");

    Conj<Caracteristica> cs1;
    cs1.Agregar("cb");
    d.Entrar(cs1,"Belgrano");
    d.Entrar(cs1,"Belgrano");
    d.Entrar(cs1,"Belgrano");
    d.Entrar(cs1,"Retiro");
    ASSERT_EQ(d.CantidadRobotsActivos(),4);
    d.Mover(0, "Retiro");
    d.Mover(1, "Retiro");
    d.Mover(2, "Retiro");
    d.Mover(0, "Belgrano");
    d.Mover(1, "Belgrano");

    Conj<RUR> peores; // {0,1} con 2 infracciones
    peores.Agregar(0);
    peores.Agregar(1);

    d.Inspeccion("Retiro"); // No debe volar a ninguno de los mas infractores
    ASSERT(peores.Pertenece(d.ElMasInfractor()));

    infoRobots info = getDatosRobotsActivos(d);
    ASSERT(info.caracteristicas.Definido(0) && info.caracteristicas.Definido(1));

    d.Inspeccion("Belgrano"); // Debe volar a uno de los dos mas infractores
    ASSERT(peores.Pertenece(d.ElMasInfractor()));
    info = getDatosRobotsActivos(d);
    ASSERT(!(info.caracteristicas.Definido(0) && info.caracteristicas.Definido(1)));
}
Esempio n. 5
0
Conj<Posicion> Campus::IngresosMasCercanos(Posicion pos) {
    Conj<Posicion> conjunto = Conj<Posicion>();
    Posicion superior = Posicion(pos.x, 0);
    Posicion inferior = Posicion(pos.x, Filas()-1);
    if (Distancia(pos, superior) <= Distancia(pos, inferior))
        conjunto.Agregar(superior);
    if (Distancia(pos, superior) >= Distancia(pos, inferior))
        conjunto.Agregar(inferior);
    return conjunto;
}
Esempio n. 6
0
/**
 * Ejemplo de caso de test, con llamadas a las rutinas de aserción 
 * definidas en mini_test.h
 */
void test_ciudad_simple()
{
    Conj<Estacion> estaciones;
    estaciones.Agregar("Belgrano");
    estaciones.Agregar("Retiro");
    estaciones.Agregar("Martinez");

    Driver caba(estaciones);

    caba.AgregarSenda("Belgrano", "Retiro", "(trenDePasajeros | trenDeCarga) & !trenDeLaAlegria");
    caba.AgregarSenda("Martinez", "Retiro", "trenDeLaAlegria");
    caba.AgregarSenda("Martinez", "Belgrano", "trenDePasajeros");

    Conj<Caracteristica> r1, r2, r3;
    r1.Agregar("trenDePasajeros");
    r2.Agregar("trenDeCarga");
    r3.Agregar("trenDeLaAlegria");

    caba.Entrar(r1,"Belgrano"); // RUR 0
    caba.Entrar(r2,"Retiro");   // RUR 1
    caba.Entrar(r3,"Martinez"); // RUR 2

    ASSERT_EQ(caba.CantidadEstaciones(), 3);
    ASSERT_EQ(caba.CantidadRobotsActivos(), 3);
    ASSERT_EQ(caba.CantidadDeSendasParaEstacion("Belgrano"), 2);

    caba.Mover(0,"Retiro");    // RUR 0: 0 infracciones
    caba.Mover(0,"Martinez");  // RUR 0: 1 infracciones

    caba.Mover(1,"Belgrano");  // RUR 1: 0 infracciones
    caba.Mover(1,"Martinez");  // RUR 1: 1 infracciones

    caba.Mover(2,"Belgrano");  // RUR 2: 1 infracciones
    caba.Mover(2,"Retiro");    // RUR 2: 2 infracciones

    Dicc<RUR,Nat> infraccionesRobots;

    // Chequeo infracciones iterando los robots
    for (Nat i = 0;  i< caba.CantidadRobotsActivos(); ++i)
        infraccionesRobots.Definir(caba.IesimoRobotActivo(i),caba.CantInfraccionesIesimoRobotActivo(i));

    ASSERT_EQ(infraccionesRobots.Significado(0), 1);
    ASSERT_EQ(infraccionesRobots.Significado(1), 1);
    ASSERT_EQ(infraccionesRobots.Significado(2), 2);

    ASSERT_EQ(caba.ElMasInfractor(),2);

    // Vuela un robot
    caba.Inspeccion("Retiro");
    ASSERT_EQ(caba.CantidadRobotsActivos(),2);

}
Esempio n. 7
0
void test_prefijos() {
    Conj<Estacion> es;
    es.Agregar("Belgrano");
    es.Agregar("Retiro");
    es.Agregar("Martinez");
    Driver d(es);
    d.AgregarSenda("Belgrano","Retiro","a|ab|abcd|abcdef");
    d.AgregarSenda("Martinez","Retiro","abcd");

    Conj<Caracteristica> cs1,cs2,cs3,cs4,cs5,cs6;
    cs1.Agregar("a");
    d.Entrar(cs1,"Belgrano"); //

    cs2.Agregar("abc");
    d.Entrar(cs2,"Belgrano");

    cs3.Agregar("abcdef");
    d.Entrar(cs3,"Belgrano");

    cs4.Agregar("abcdefg");
    d.Entrar(cs4,"Belgrano");

    cs5.Agregar("a");
    cs5.Agregar("ab");
    cs5.Agregar("abc");
    cs5.Agregar("abcde");
    cs5.Agregar("abcdef");
    cs5.Agregar("abcdefg");
    d.Entrar(cs5,"Retiro");

    cs6.Agregar("a");
    cs6.Agregar("abcd");
    cs6.Agregar("abcdefg");
    d.Entrar(cs6,"Retiro");

    for (RUR i=0; i < 4; ++i)
        d.Mover(i,"Retiro");

    d.Mover(4,"Martinez");
    d.Mover(5,"Martinez");

    infoRobots info = getDatosRobotsActivos(d);
    ASSERT_EQ(info.infracciones.Significado(0),0);
    ASSERT_EQ(info.infracciones.Significado(1),1);
    ASSERT_EQ(info.infracciones.Significado(2),0);
    ASSERT_EQ(info.infracciones.Significado(3),1);
    ASSERT_EQ(info.infracciones.Significado(4),1);
    ASSERT_EQ(info.infracciones.Significado(5),0);
}
Esempio n. 8
0
void test_ciudad_simple()
{
    Conj<Estacion> estaciones;
    estaciones.Agregar("Belgrano");
    estaciones.Agregar("Retiro");
    estaciones.Agregar("Martinez");

    Driver caba(estaciones);

    caba.AgregarSenda("Belgrano", "Retiro", "(trenDePasajeros | trenDeCarga) & !trenDeLaAlegria");
    caba.AgregarSenda("Martinez", "Retiro", "trenDeLaAlegria");
    caba.AgregarSenda("Martinez", "Belgrano", "trenDePasajeros");

    Conj<Caracteristica> r1, r2, r3;
    r1.Agregar("trenDePasajeros");
    r2.Agregar("trenDeCarga");
    r3.Agregar("trenDeLaAlegria");

    caba.Entrar(r1,"Belgrano"); // RUR 0
    caba.Entrar(r2,"Retiro");   // RUR 1
    caba.Entrar(r3,"Martinez"); // RUR 2

    ASSERT_EQ(caba.CantidadEstaciones(), 3);
    ASSERT_EQ(caba.CantidadRobotsActivos(), 3);
    ASSERT_EQ(caba.CantidadDeSendasParaEstacion("Belgrano"), 2);

    caba.Mover(0,"Retiro");    // RUR 0: 0 infracciones
    caba.Mover(0,"Martinez");  // RUR 0: 1 infracciones

    caba.Mover(1,"Belgrano");  // RUR 1: 0 infracciones
    caba.Mover(1,"Martinez");  // RUR 1: 1 infracciones

    caba.Mover(2,"Belgrano");  // RUR 2: 1 infracciones
    caba.Mover(2,"Retiro");    // RUR 2: 2 infracciones

    infoRobots info = getDatosRobotsActivos(caba);

    ASSERT_EQ(info.infracciones.Significado(0), 1);
    ASSERT_EQ(info.infracciones.Significado(1), 1);
    ASSERT_EQ(info.infracciones.Significado(2), 2);

    ASSERT_EQ(caba.ElMasInfractor(),2);

    // Vuela un robot
    caba.Inspeccion("Retiro");
    ASSERT_EQ(caba.CantidadRobotsActivos(),2);

}
Esempio n. 9
0
const Conj<Posicion> Campus::IngresosMasCercanos(const Posicion& p) const {
	assert(PosValida(p));

	Conj<Posicion> res;
	Posicion p1(p.x, 0);
	Posicion p2(p.x, filas - 1);
	if( Distancia(p, p1) < Distancia(p, p2) ) {
		res.Agregar(p1);
	} else if( Distancia(p, p1) > Distancia(p, p2) ) {
		res.Agregar(p2);
	} else {
		res.Agregar(p1);
		res.Agregar(p2);
	}
	return res;
}
Esempio n. 10
0
// Mover robots
void test_mover_robots() {
    Conj<Estacion> es;
    es.Agregar("Belgrano");
    es.Agregar("Retiro");
    Driver d(es);
    d.AgregarSenda("Belgrano","Retiro","ca");

    Conj<Caracteristica> cs1,cs2;
    cs1.Agregar("ca");
    cs2.Agregar("cb");
    d.Entrar(cs1,"Belgrano");
    d.Entrar(cs2,"Retiro");
    d.Mover(0,"Retiro");
    d.Mover(1,"Belgrano");
    infoRobots info = getDatosRobotsActivos(d);
    ASSERT_EQ(info.estaciones.Significado(0),"Retiro");
    ASSERT_EQ(info.estaciones.Significado(1),"Belgrano");
}
Esempio n. 11
0
void test_no_sumar_infracciones() {
    Conj<Estacion> es;
    es.Agregar("Belgrano");
    es.Agregar("Retiro");
    Driver d(es);
    d.AgregarSenda("Belgrano","Retiro","ca");

    Conj<Caracteristica> cs1;
    cs1.Agregar("ca");
    d.Entrar(cs1,"Belgrano");
    // Hago varios mover ida y vuelta: no debe sumar infracciones
    for (int i = 0; i < 10; ++i)
        d.Mover(0, i%2 == 0 ? "Retiro" : "Belgrano");

    infoRobots info = getDatosRobotsActivos(d);
    ASSERT_EQ(info.estaciones.Significado(0),"Belgrano");
    ASSERT_EQ(info.infracciones.Significado(0),0);
}
Esempio n. 12
0
Conj<Compu> Red::Computadoras(){
	vector<string> vec = vecinos.claves();
  
  Conj<Compu> con;
  for(unsigned int i = 0; i<vec.size(); i++){
    con.Agregar(vec[i]);
  }

	return con;
}
Esempio n. 13
0
Conj<Compu> Red::Vecinos(Compu c){
  DiccString<unsigned int> * x = vecinos.obtener(c);

	vector<string> vec = x->claves();
  
  Conj<Compu> con;
  for(unsigned int i = 0; i<vec.size(); i++){
    con.Agregar(vec[i]);
  }
  return con;
}
Esempio n. 14
0
void test_restriccion_tautologia_contradiccion() {
    Conj<Estacion> es;
    es.Agregar("Belgrano");
    es.Agregar("Retiro");
    es.Agregar("Martinez");
    Driver d(es);
    d.AgregarSenda("Belgrano","Retiro","ser|!ser");
    d.AgregarSenda("Retiro","Martinez","casa&!casa");

    Conj<Caracteristica> cs1;
    cs1.Agregar("cb");
    d.Entrar(cs1,"Belgrano");

    d.Mover(0,"Retiro");
    // El mover no sumo
    ASSERT_EQ(d.CantInfraccionesIesimoRobotActivo(0),0);
    d.Mover(0,"Martinez");
    // El mover si sumo
    ASSERT_EQ(d.CantInfraccionesIesimoRobotActivo(0),1);
}
Esempio n. 15
0
aed2::Conj<Driver::Registro> Driver::vistaJoin(const NombreTabla& tabla1, const NombreTabla& tabla2)
{
  Conj<Driver::Registro> res;
  Conj<modulos::Registro> cr = b.VistaJoin(tabla1,tabla2).Siguiente().Registros();
  typename Conj<modulos::Registro>::Iterador itr = cr.CrearIt();
  while(itr.HaySiguiente()){
    res.Agregar(RNRS(itr.Siguiente()));
    itr.Avanzar();
  }
  return res;
  //assert(false);
}
Esempio n. 16
0
// Entrar robots
void test_entrar() {
    Conj<Estacion> es;
    es.Agregar("Belgrano");
    es.Agregar("Retiro");
    Driver d(es);

    Conj<Caracteristica> cs1,cs2,cs3;
    cs1.Agregar("ca");
    cs2.Agregar("ca");
    cs2.Agregar("cb");
    cs3.Agregar("cc");
    d.Entrar(cs1,"Belgrano");
    d.Entrar(cs2,"Retiro");
    d.Entrar(cs3,"Retiro");
    ASSERT_EQ(d.CantidadRobotsActivos(),3);

    infoRobots info = getDatosRobotsActivos(d);
    ASSERT_EQ(info.estaciones.Significado(0),"Belgrano");
    ASSERT_EQ(info.estaciones.Significado(1),"Retiro");
    ASSERT_EQ(info.estaciones.Significado(2),"Retiro");
}
Esempio n. 17
0
void test_mapa() {
    Conj<Estacion> es;
    es.Agregar("Belgrano");
    es.Agregar("Retiro");
    es.Agregar("Olivos");
    es.Agregar("Martinez");
    Driver d(es);
    d.AgregarSenda("Belgrano","Retiro","ca");
    d.AgregarSenda("Retiro","Olivos","cb");
    d.AgregarSenda("Retiro","Martinez","cc");
    d.AgregarSenda("Belgrano","Martinez","cc");

    // Verifica # estaciones
    ASSERT_EQ(d.CantidadEstaciones(),4);

    // Verifica # sendas x estacion
    ASSERT_EQ(d.CantidadDeSendasParaEstacion("Retiro"),3);
    ASSERT_EQ(d.CantidadDeSendasParaEstacion("Belgrano"),2);
    ASSERT_EQ(d.CantidadDeSendasParaEstacion("Olivos"),1);
    ASSERT_EQ(d.CantidadDeSendasParaEstacion("Martinez"),2);
}
Esempio n. 18
0
aed2::Conj<Driver::Registro> Driver::buscar(const NombreTabla& tabla, const aed2::Driver::Registro& criterio) const
{
  Conj<Driver::Registro> res;
  modulos::Registro crit = RSRN(criterio);
  Conj<modulos::Registro> cr = b.DameTabla(tabla).BuscarT(crit);
  typename Conj<modulos::Registro>::Iterador itr = cr.CrearIt();
  while(itr.HaySiguiente()){
    res.Agregar(RNRS(itr.Siguiente()));
    itr.Avanzar();
  }
  return res;
  //assert(false);
}
Esempio n. 19
0
void test_restriccion_compleja() {
    Conj<Estacion> es;
    es.Agregar("Belgrano");
    es.Agregar("Retiro");
    es.Agregar("Martinez");
    Driver d(es);
    d.AgregarSenda("Belgrano","Retiro","(ca&!cb) | (!cc | (unaCaracteristicaDeCasiCasiCasiCincuentaYNueveCaracteres & ce))");

    Conj<Caracteristica> cs1,cs2,cs3,cs4;
    cs1.Agregar("ca");
    d.Entrar(cs1,"Belgrano"); //

    cs2.Agregar("ca");
    cs2.Agregar("cb");
    cs2.Agregar("cc");
    d.Entrar(cs2,"Belgrano");

    cs3.Agregar("ca");
    cs3.Agregar("cb");
    cs3.Agregar("cc");
    cs3.Agregar("unaCaracteristicaDeCasiCasiCasiCincuentaYNueveCaracteres");
    cs3.Agregar("ce");
    d.Entrar(cs3,"Belgrano");

    cs4.Agregar("ca");
    cs4.Agregar("cb");
    cs4.Agregar("cc");
    cs4.Agregar("unaCaracteristicaDeCasiCasiCasiCincuentaYNueveCaracteres");
    d.Entrar(cs4,"Belgrano");

    for (RUR i=0; i < 4; ++i)
    d.Mover(i,"Retiro");

    infoRobots info = getDatosRobotsActivos(d);
    ASSERT_EQ(info.infracciones.Significado(0),0);
    ASSERT_EQ(info.infracciones.Significado(1),1);
    ASSERT_EQ(info.infracciones.Significado(2),0);
    ASSERT_EQ(info.infracciones.Significado(3),1);
}
Esempio n. 20
0
void test_inspeccion_simple() {
    Conj<Estacion> es;
    es.Agregar("Belgrano");
    es.Agregar("Retiro");
    Driver d(es);
    d.AgregarSenda("Belgrano","Retiro","ca");

    Conj<Caracteristica> cs1;
    cs1.Agregar("cb");
    d.Entrar(cs1,"Belgrano");
    d.Entrar(cs1,"Retiro");
    ASSERT_EQ(d.CantidadRobotsActivos(),2);
    d.Mover(0, "Retiro");
    d.Inspeccion("Retiro"); // debe volar el RUR 0

    ASSERT_EQ(d.CantidadRobotsActivos(),1);

    infoRobots info = getDatosRobotsActivos(d);
    // Chequeo que el que queda no fue modificado
    ASSERT_EQ(info.estaciones.Significado(1),"Retiro");
    ASSERT_EQ(info.infracciones.Significado(1),0);
}
Esempio n. 21
0
void test_no_reusa_RURs() {
    Conj<Estacion> es;
    es.Agregar("Belgrano");
    es.Agregar("Retiro");
    Driver d(es);
    d.AgregarSenda("Belgrano","Retiro","ca");

    Conj<Caracteristica> cs1;
    cs1.Agregar("cb");
    d.Entrar(cs1,"Belgrano");
    d.Entrar(cs1,"Retiro");
    d.Mover(0, "Retiro");
    d.Inspeccion("Retiro"); // debe volar el RUR 0

    infoRobots info = getDatosRobotsActivos(d);
    ASSERT(!info.infracciones.Definido(0));

    d.Entrar(cs1,"Belgrano"); // no debe reusar RUR 0

    info = getDatosRobotsActivos(d);
    ASSERT(!info.infracciones.Definido(0)); // RUR 0 tiene que seguir inactivo
}
Esempio n. 22
0
void test_mapa() {
    Mapa mapa1;
    
    mapa1.Agregar("Hola");
    mapa1.Agregar("Coso");
    mapa1.Agregar("Cafe");
    
    Rest res1("(rojo | Amarillo) & !VERDE");
    Rest res2("Amarillo");
    mapa1.Conectar("Hola", "Coso", res1);
    mapa1.Conectar("Hola", "Cafe", res2);
    
    ASSERT(mapa1.Conectadas("Hola", "Coso"));
    ASSERT(mapa1.Conectadas("Hola", "Cafe"));
    ASSERT(!mapa1.Conectadas("Coso", "Cafe"));

    ASSERT_EQ(mapa1.NroConexion("Hola", "Coso"), 0);
    ASSERT_EQ(mapa1.NroConexion("Coso", "Hola"), 0);
    ASSERT_EQ(mapa1.NroConexion("Hola", "Cafe"), 1);
    ASSERT_EQ(mapa1.NroConexion("Cafe", "Hola"), 1);
    
    Conj<Caracteristica> carac;
    carac.Agregar("Amarillo");
    carac.Agregar("VERDE");
    
    Arreglo<bool> sendas = mapa1.EvaluarSendas(carac);
    ASSERT(!sendas[0]);
    ASSERT(sendas[1]);
    
    Mapa mapa2(mapa1);
    
    mapa2.Conectar("Coso","Cafe", res1);
    
    ASSERT_EQ(mapa2.NroConexion("Coso", "Cafe"), 2);
    ASSERT_EQ(mapa2.NroConexion("Cafe", "Coso"), 2);
    ASSERT(mapa2.Conectadas("Coso", "Cafe"));
    ASSERT(!mapa1.Conectadas("Coso", "Cafe"));
}
Esempio n. 23
0
Conj<Posicion> Campus::Vecinos(const Posicion& p) const {
	assert(PosValida(p));

	Conj<Posicion> res;

	if(p.x > 0) {
		res.Agregar(Posicion(p.x - 1, p.y));
	}

	if(p.y > 0) {
		res.Agregar(Posicion(p.x, p.y - 1));
	}

	if(p.y < filas - 1) {
		res.Agregar(Posicion(p.x, p.y + 1));
	}

	if(p.x < columnas - 1) {
		res.Agregar(Posicion(p.x + 1, p.y));
	}

	return res;
}
Esempio n. 24
0
void test_inspeccion_orden_prioridades() {
    Conj<Estacion> es;
    es.Agregar("Belgrano");
    es.Agregar("Retiro");
    Driver d(es);
    d.AgregarSenda("Belgrano","Retiro","ca");

    Conj<Caracteristica> cs1;
    cs1.Agregar("cb");
    d.Entrar(cs1,"Belgrano");
    d.Entrar(cs1,"Retiro");
    d.Entrar(cs1,"Belgrano");
    d.Entrar(cs1,"Retiro");
    d.Entrar(cs1,"Retiro");

    d.Mover(2, "Retiro");
    d.Mover(2, "Belgrano");
    d.Mover(2, "Retiro");
    d.Mover(1, "Belgrano");
    d.Mover(1, "Retiro");
    d.Mover(0, "Retiro");

    ASSERT_EQ(d.CantidadRobotsActivos(),5);

    d.Inspeccion("Retiro"); // debe volar RUR 2
    ASSERT_EQ(d.CantidadRobotsActivos(),4);
    ASSERT(!getDatosRobotsActivos(d).infracciones.Definido(2));
    d.Inspeccion("Retiro"); // debe volar RUR 1
    ASSERT_EQ(d.CantidadRobotsActivos(),3);
    ASSERT(!getDatosRobotsActivos(d).infracciones.Definido(1));
    d.Inspeccion("Retiro"); // debe volar RUR 0
    ASSERT_EQ(d.CantidadRobotsActivos(),2);
    ASSERT(!getDatosRobotsActivos(d).infracciones.Definido(0));
    d.Inspeccion("Retiro"); // no debe volar nadie
    ASSERT_EQ(d.CantidadRobotsActivos(),2);
    ASSERT(getDatosRobotsActivos(d).infracciones.Definido(3));
}
Esempio n. 25
0
void campusSeguro::moverAgente(Agente a)
{
    Posicion posActual = posAgente(a);
    //Conj<campus::Posicion>::Iterador itPos = _hippies.Claves();
    DiccPalabra<Posicion>::itDiccP itPos = _hippies.Claves();
    Posicion nuevaPos = proxPosicion(posActual, itPos );

    if( !(posActual == nuevaPos) )
    {
        grilla.Obtener( nuevaPos ).tag =  grilla.Obtener( posActual ).tag;
        grilla.Obtener( nuevaPos ).id =   grilla.Obtener( posActual ).id;
        grilla.Obtener( posActual).id =  4;
        grilla.Obtener( nuevaPos ).placa =  grilla.Obtener( posActual ).placa;
        grilla.Obtener( nuevaPos ).datosAgente =  grilla.Obtener( posActual ).datosAgente;
        Conj<Posicion> c;
        c.Agregar(nuevaPos);
        actualizarDatosAgentes(c);
        actualizarEstYHippie(_campus.Vecinos(nuevaPos));// en el diseño aca hay un Siguiente(itVecinos) que esta demas.
        actualizarVecinos(nuevaPos);
    }
}
Esempio n. 26
0
Conj<Lista<Compu> > Red::CaminosDeLargoN(Compu c1, Compu c2, Nat n){
  Conj<Lista<Compu> > caminos;	
  if(n == 0){
    Lista<Compu> camino;
    camino.AgregarAtras(c1);
    caminos.AgregarRapido(camino);
  } else {
    Conj<Compu> vec = this->Vecinos(c1);
    Conj<Compu>::Iterador itVecinos(vec);
    while(itVecinos.HaySiguiente()){
      Compu v = itVecinos.Siguiente();
      Conj<Lista<Compu> > cams = this->CaminosDeLargoN(v, c2, n-1);

      Conj<Lista<Compu> >::Iterador itCaminos(cams);

      while(itCaminos.HaySiguiente()){
        Lista<Compu> camino = itCaminos.Siguiente();
        if(camino.Ultimo() == c2){
          Lista<Compu> camino2 = camino;
          camino2.AgregarAdelante(c1);
          caminos.Agregar(camino2);
        } 
        itCaminos.Avanzar();
      }
      itVecinos.Avanzar();
    }
  }

  Conj<Lista<Compu> >::Iterador itCaminos2(caminos);
  while(itCaminos2.HaySiguiente()){
    if(itCaminos2.Siguiente().Ultimo() != c2){
      itCaminos2.EliminarSiguiente();
    }
	   
		if(itCaminos2.HaySiguiente()) itCaminos2.Avanzar(); //esta linea faltaba en el tp
  }

  return caminos;
}