/*
* finalizarUnPedidoDeUnClient() consiste en la creacion, asignacion y posterior finalizacion
* de un pedido, dos veces con lo cual se suma 6 veces dos tiempos distintos de finalizacion
* por utlimo se calcula el promedio de atencion de Reparacion Simple comprobando que da el resultado
* Deseado
* */
@Test // (expected = UnsupportedOperationException.class )
public void finalizarUnPedidoDeUnClient() {
Tiempo tiempoDeFinalizacion = new Tiempo().nuevoTiempo(10, 15);
Pedido pedidoAgregar =
builderPedido
.armarPedidoBase(autoDePrueba)
.addReparacionSimple()
.addReparacionSimple()
.addReparacionSimple()
.build();
clienteClassicSinDeuda.agregarPedido(pedidoAgregar);
pedidoAgregar.finalizar(tiempoDeFinalizacion);
tiempoDeFinalizacion = new Tiempo().nuevoTiempo(12, 15);
clienteClassicSinDeuda.agregarPedido(pedidoAgregar);
pedidoAgregar.finalizar(tiempoDeFinalizacion);
assertTrue(
Tiempo.sonTiemposIguales(
pedidoAgregar.calcularTiempoDeAtencion(), new Tiempo().nuevoTiempo(11, 15)));
}
@Override
public DataUsuario obtenerDatosUsuario() {
ArrayList<DataProducto> dataProductos = new ArrayList<>();
ArrayList<DataPedido> dataPedidos = new ArrayList<>();
if (!productos.isEmpty()) {
for (Producto p : productos) {
dataProductos.add(p.obtenerDatosProducto());
}
}
ArrayList<Pedido> lp = getPedidos();
if (!lp.isEmpty()) {
for (Pedido pe : lp) {
dataPedidos.add(pe.obtenerDatosPedido());
}
}
DataUsuario dataUsuario =
new DataRestaurante(
rutaImagen,
dataProductos,
getPuntajePromedio(),
cantidadPuntuaciones,
this.getNickname(),
this.getMail(),
this.getNombre(),
this.getPass(),
this.getDireccion(),
dataPedidos);
return dataUsuario;
}
@Test
public void listaDoisItemVariasQdd() {
Pedido p = new Pedido();
Calendar data = GregorianCalendar.getInstance();
;
p.setNome("Thiago");
p.setData(data);
List<Item> itens = new ArrayList<Item>();
Item i1 = new Item();
i1.setTipo("PS3");
i1.setQuantidade(5);
i1.setValor(900.0);
itens.add(i1);
Item i2 = new Item();
i2.setTipo("XBOX");
i2.setQuantidade(10);
i2.setValor(800.0);
itens.add(i2);
p.setItens(itens);
Assert.assertEquals(12500.0, p.calculaValorTotal());
}
/** Loop principal Gera pedidos aleat�rios para fornecedores aleat�rios */
public void run() {
Pedido pedido = new Pedido();
for (; ; ) {
try {
Thread.sleep(Projeto2.randInt(500));
} catch (InterruptedException e) {
Projeto2.setVerbose(true);
Projeto2.debug("interrompido enquanto dormia");
return;
}
for (Cana g : Cana.values()) {
pedido.set(g, Projeto2.randInt(1, 10));
}
Cana g = Cana.randChoice();
Projeto2.debug("solicitando %s ao atravessador de cana %s", pedido, g);
try {
Projeto2.especialista(g).get(pedido);
} catch (InterruptedException e) {
Projeto2.setVerbose(true);
Projeto2.debug(
"interrompido durante solicita��o%n" + " %s do fornecedor de cana %s", pedido, g);
return;
}
Projeto2.debug("recebi %s do fornecedor de cana %s", pedido, g);
consome(pedido);
}
} // run()
@Test
public void listaVazia() {
Pedido p = new Pedido();
Calendar data = GregorianCalendar.getInstance();
;
p.setNome("Thiago");
p.setData(data);
Assert.assertEquals(0.0, p.calculaValorTotal());
}
public static void main(String[] args) {
EntityManagerFactory factory = Persistence.createEntityManagerFactory("K21_mapeamento_pu");
EntityManager manager = factory.createEntityManager();
manager.getTransaction().begin();
Pedido p = new Pedido();
Cliente c = new Cliente();
p.setCliente(c);
}
@Test
public void testOK() throws ParseException {
Date dataValidade = (Date) formatter.parse("2012-12-25");
Date dataLimite = (Date) formatter.parse("2012-05-15");
Pedido pedido = new Pedido(dataValidade, "12345", 500.0f, dataLimite);
assertEquals("12345", pedido.getNumCartao());
assertEquals(500.0f, pedido.getValor(), 0.00001f);
assertEquals(dataValidade, pedido.getDataValidade());
assertEquals(dataLimite, pedido.getDataLimite());
}
/*
* finalizarUnPedidoBaseDeUnClient() consiste en la creacion, asignacion y posterior finalizacion
* de un pedido base y se espera que el mismo tire la excepcion que no puede finalizarse.
* */
@Test
public void finalizarUnPedidoBaseDeUnClient() {
Tiempo tiempoDeFinalizacion = new Tiempo().nuevoTiempo(10, 15);
Pedido pedidoAgregar =
builderPedido.armarPedidoBase(autoDePrueba).addReparacionSimple().build();
pedidoAgregar.finalizar(tiempoDeFinalizacion);
assertTrue(
Tiempo.sonTiemposIguales(
pedidoAgregar.calcularTiempoDeAtencion(), tiempoDeFinalizacion.nuevoTiempo(10, 15)));
}
public Pedido finalizarPedido() {
Pedido pedido = new Pedido();
pedido.setData(Calendar.getInstance());
pedido.setItens(new LinkedHashSet<>(this.itensDeCompra));
this.pagamento = this.clienteRest.confirmarPagamento(pagamento);
pedido.setPagamento(pagamento);
this.enviador.enviar(pedido);
this.limparCarrinho();
return pedido;
}
@Transactional
@Test
public void test() throws SQLException {
Pedido pedido = Pedido.newPedido(123);
pedido.estadoPedido = EstadoPedido.PARCIALMENTE_FATURADO;
entityManager.persist(pedido);
@SuppressWarnings("deprecation")
Connection connection = entityManager.unwrap(Session.class).connection();
PreparedStatement pst =
connection.prepareStatement("select estado_pedido from Pedido where id = ?");
pst.setLong(1, pedido.getId());
ResultSet rs = pst.executeQuery();
assertTrue(rs.next());
String value = rs.getString(1);
assertEquals("S", value);
}
@Test
public void listaUmItemUmaQdd() {
Pedido p = new Pedido();
Calendar data = GregorianCalendar.getInstance();
;
p.setNome("Thiago");
p.setData(data);
List<Item> itens = new ArrayList<Item>();
Item i = new Item();
i.setTipo("PS3");
i.setQuantidade(1);
i.setValor(900.0);
itens.add(i);
p.setItens(itens);
Assert.assertEquals(900.0, p.calculaValorTotal());
}
public EditarPedidoInterface(Pedido pedido) {
initComponents();
String[] data = pedido.getDatapedido().split("/");
this.nomeprod.setDocument(new LengthRestrictedDocument(50));
this.nomefab.setDocument(new LengthRestrictedDocument(50));
this.model.setDocument(new LengthRestrictedDocument(20));
this.quant.setDocument(new LengthRestrictedDocument(10));
this.valor.setDocument(new LengthRestrictedDocument(10));
this.obs.setDocument(new LengthRestrictedDocument(200));
this.dia.setDocument(new IntegersOnlyDocument(2));
this.mes.setDocument(new IntegersOnlyDocument(2));
this.ano.setDocument(new IntegersOnlyDocument(4));
this.dia.setText(data[0]);
this.mes.setText(data[1]);
this.ano.setText(data[2]);
this.nomeprod.setText(pedido.getNomeproduto());
this.nomefab.setText(pedido.getNomefabricante());
this.model.setText(pedido.getModelo());
this.quant.setText(pedido.getQuantidade());
this.valor.setText(pedido.getValor());
// this.obs.setText(pedido.getObs);
this.dia.setEnabled(false);
this.mes.setEnabled(false);
this.ano.setEnabled(false);
this.nomeprod.setEnabled(false);
this.nomefab.setEnabled(false);
this.model.setEnabled(false);
this.quant.setEnabled(false);
this.model.setEnabled(false);
this.obs.setEditable(false);
this.pedidoatual = pedido;
}
/**
* Programa principal para o projeto 2.
*
* @param args argumentos da linha de comando.
*/
public static void main(String[] args) {
// Faz o parsing dos argumentos da linha de comando.
GetOpt options = new GetOpt("Projeto2", args, "vr");
int opt;
while ((opt = options.nextOpt()) != -1) {
switch (opt) {
default:
usage();
break;
case 'v':
verbose = true;
break;
case 'r':
rand = new Random(0);
break;
}
}
if (rand == null) {
rand = new Random();
}
if (options.optind != args.length - 2) {
usage();
}
alambiqueCount = Integer.parseInt(args[options.optind]);
int iteracoes = Integer.parseInt(args[options.optind + 1]);
// Cria os atravessadores
atravessadores = new EnumMap<Cana, Atravessador>(Cana.class);
for (Cana g : Cana.values()) {
// Voc� precisa implementar a classe AtravessadorImpl para o programa funcionar.
atravessadores.put(g, new AtravessadorImpl(g));
}
// Criar o �nico fornecedor.
fornecedor = new Fornecedor(iteracoes);
Thread threadFornecedor = new Thread(fornecedor, "Fornecedor");
alambiques = new Alambique[alambiqueCount];
alambiqueThreads = new Thread[alambiqueCount];
for (int i = 0; i < alambiqueCount; i++) {
alambiques[i] = new Alambique();
alambiqueThreads[i] = new Thread(alambiques[i], "Alambique " + i);
}
// Inicia os threads
// Todos eles tem prioridade mais baixa que o thread pricniapl ent�o nenhum deles
// come�ar� a rodar antes que todos tenham sidos inicializados.
threadFornecedor.setPriority(Thread.NORM_PRIORITY - 1);
threadFornecedor.start();
for (Thread t : alambiqueThreads) {
t.setPriority(Thread.NORM_PRIORITY - 1);
t.start();
}
// Espera que todos os threads sejam finalizados
try {
// O thread do fornecedor ser� finalizado quando ele concluir todas as itera��es
// especificadas.
threadFornecedor.join();
// Espera 3 segundos para dar uma chance para os threads do alambique terminarem
// depois disso, todos que n�o finalizarem ser�o interrompidos.
Thread.sleep(3000);
for (Thread t : alambiqueThreads) {
t.interrupt();
t.join();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
// imprime o estado final
out.printf("**** Finalizando%n");
Pedido quant;
Pedido balanco = new Pedido();
int produzido = 0;
int nosAtravessadores = 0;
int consumido = 0;
quant = fornecedor.getProducao();
out.printf("Produzido %s%n", quant);
for (Cana g : Cana.values()) {
int n = quant.get(g);
balanco.troca(g, n);
produzido += n;
}
for (Cana g : Cana.values()) {
quant = atravessadores.get(g).getEstoqueDisponivel();
for (Cana c1 : Cana.values()) {
int n = quant.get(c1);
balanco.troca(c1, -n);
nosAtravessadores += n;
}
}
for (int i = 0; i < alambiqueCount; i++) {
quant = alambiques[i].getConsumo();
out.printf("O Alambique %d consumiu %s%n", i, quant);
for (Cana g : Cana.values()) {
int n = quant.get(g);
balanco.troca(g, -n);
consumido += n;
}
}
out.printf("O balan�o final � %s%n", balanco);
out.printf(
"Total: produzido = %d, consumido = %d,"
+ " sobrando nos atravessadores = %d, liquido = %d%n",
produzido, consumido, nosAtravessadores, (produzido - consumido - nosAtravessadores));
} // main(String[])
/** M�todo principal */
public static void main(String[] args) {
// faz o parsing dos argumentos da linha de comnaod
GetOpt options = new GetOpt("Projeto3", args, "vr");
int opt;
while ((opt = options.nextOpt()) != -1) {
switch (opt) {
default:
uso();
break;
case 'v':
verbose = true;
break;
case 'r':
rand = new Random(0);
break;
}
}
if (rand == null) {
rand = new Random();
}
if (options.optind != args.length - 3) {
uso();
}
int algoritmo = Integer.parseInt(args[options.optind + 0]);
alambiqueN = Integer.parseInt(args[options.optind + 1]);
int iteracoes = Integer.parseInt(args[options.optind + 2]);
// Cria o dep�sito
deposito = new Deposito(algoritmo);
Thread dthread = new Thread(deposito, "Deposito");
// Cria o fornecedor
fornecedor = new Fornecedor(iteracoes);
Thread fThread = new Thread(fornecedor, "Fornecedor");
// Cria os alambiques
alambiques = new Alambique[alambiqueN];
alambiqueThreads = new Thread[alambiqueN];
for (int i = 0; i < alambiqueN; i++) {
alambiques[i] = new Alambique(i);
alambiqueThreads[i] = new Thread(alambiques[i], "Alambique" + i);
}
// Inicia os threads
dthread.setPriority(Thread.NORM_PRIORITY - 1);
dthread.start();
fThread.setPriority(Thread.NORM_PRIORITY - 1);
fThread.start();
for (Thread t : alambiqueThreads) {
t.setPriority(Thread.NORM_PRIORITY - 1);
t.start();
}
// Espera at� que todos os threads sejam encerrados
try {
// O thread do fornecedor se encerra quando ele completa todas as itera��es
fThread.join();
// Aguarda 3 segundos para dar chance a todos de terminarem o que est�o fazendo,
// em seguida todos s�o interrompidos
Thread.sleep(3000);
// Mata o thread do dep�sito
dthread.interrupt();
dthread.join();
// Mata os alambiques
for (Thread t : alambiqueThreads) {
t.interrupt();
t.join();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
// imprime o estado final
out.printf("**** Programa terminando%n");
Pedido quant;
Pedido balanco = new Pedido();
int produzido = 0;
int noDeposito = 0;
int consumido = 0;
quant = fornecedor.getProducao();
out.printf("Produzido %s%n", quant);
balanco.troca(quant);
produzido += quant.total();
quant = deposito.getDisponivel();
for (Cana c1 : Cana.values()) {
int n = quant.get(c1);
balanco.troca(c1, -n);
noDeposito += n;
}
Pedido totalConsumido = new Pedido();
int totalRequisitado = 0;
int totalEspera = 0;
for (int i = 0; i < alambiqueN; i++) {
quant = alambiques[i].getConsumo();
int requisitado = alambiques[i].requisicoesConcluidas();
int espera = alambiques[i].tempoDeEspera();
totalConsumido.troca(quant);
for (Cana g : Cana.values()) {
int n = quant.get(g);
balanco.troca(g, -n);
consumido += n;
}
out.printf("Alabique %d%n", i);
out.printf(" Cana consumida: %s%n", quant);
out.printf(" Requisi��es atendidas: %d%n", requisitado);
out.printf(" Tempo total de espera: %d ms%n", espera);
if (requisitado > 0) {
out.printf(" Tempo de espera m�dio: %.2f ms%n", espera / (double) requisitado);
}
totalRequisitado += requisitado;
totalEspera += espera;
}
out.printf("Balan�o (deficit) � %s%n", balanco);
out.printf(
"Total: produzido = %d, consumido = %d," + " restando no dep�sito = %d, l�quido = %d%n",
produzido, consumido, noDeposito, (produzido - consumido - noDeposito));
out.printf(
"Requisi��es conclu�das: %d, tempo de espera m�dio %.2fms%n",
totalRequisitado, totalEspera / (double) totalRequisitado);
}
/**
* Metodo que regresa el folio solicitud de un pedido
*
* @param pedido
* @return folio solicitud
*/
public Pedido getPedido(Pedido pedido) {
return pedidos.obtenPedido(pedido.getFolioSolicitud());
}
/**
* Consome o total indicado de cana de a��car
*
* @param um vetor de resultados, um para cada tipo de cana.
*/
private synchronized void consome(Pedido pedido) {
for (Cana g : Cana.values()) {
consumido.troca(g, pedido.get(g));
}
}
