RSS

30 preguntas sobre Assertions

24 Mar

He recopilado las siguientes 30 preguntas sobre Assertions de diferentes
fuentes, citadas al final del post.

Las primeras son más teóricas, preguntando sobre las características de las Assertions y su uso adecuado o no, mientras que las siguientes se concentran en que el aspirante conozca el resultado de la ejecución.

He creído mejor esta vez no colocar las respuestas, si alguna la encontráis difícil o dudosa, podemos hablar de ella en los comentarios.

1. Suponiendo que están habilitadas las assertions, ¿cúales de las siguientes sentencias lanzarán un error?

  1. assert true : true;
  2. assert true : false;
  3. assert false : true;
  4. assert false : false;

2. ¿Cuáles de las siguientes opciones son válidas?

  1. -ae
  2. -enableassertions
  3. -source 1.4
  4. -disablesystemassertions
  5. -dea

3. ¿Cuál es el nombre de la excepción lanzada por una sentencia assertion?

  1. Depends on the assertion statement.
  2. FailedAssertion
  3. AssertionException
  4. RuntimeException
  5. AssertionError
  6. Error

4. ¿Qué puede provocar que una sentencia assert sea ignorada?

  1. Nada.
  2. Usando las opciones de compilación correctas.
  3. Usando las opciones de tiempo ejecución correctas.
  4. Usando las opciones de compilación y tiempo de ejecución correctas.

5. Suponiendo que las assertions están habilitadas, dado el siguiente método, ¿qué sentencias lanzarán una excepción?


static int inv(int value) {
assert value > -50 : value < 100;
return 100/value;
}

  1. inv(-50)
  2. inv(0)
  3. inv(50)
  4. inv(100)
  5. inv(150)

6. ¿Qué opciones de tiempo de ejecución habilitarán las assertions de la clase org.example.ttp.Bottle?

  1. -ea
  2. -ea:Bottle
  3. -ea:org.example
  4. -ea:org…
  5. -enableexceptions:org.example.ttp.Bottle
  6. -ea:org.example.ttp

7. ¿Cuál será el resultado de compilar y ejecutar el siguiente código con las assertions habilitadas?

public class TernaryAssertion {
    public static void assertBounds(int low, int high, int value) {
        assert ( value > low ? value < high : false ) : (value < high ? "too low" : "too high" );
     }
     public static void main(String[] args) {
         assertBounds(100, 200, 150);
     }
}
  1. La compilacion falla porque el método llamado assertBounds no puede comenzar con la palabra clave assert.
  2. La compilacion falla porque la sentencia assert es invalida.
  3. La compilacion es correcta y el programa se ejecuta sin errores.
  4. La compilacion es correcta pero se lanza un AssertionError con el mensaje “too low”
  5. La compilación es correcta pero se lanza un AssertionError con el mensaje “too high”

8. ¿Cuáles de las siguientes afirmaciones son correctas sobre la clase AssertionError?

  1. Es una excepción comprobada.
  2. Tiene un método toString().
  3. Tiene un método getErrorMessage().
  4. Puede ser capturado en una sentencia try-catch

9. ¿Cuáles de las siguientes clases es la superclase directa de AssertionError?

  1. Object.
  2. Throwable.
  3. Exception.
  4. Error.
  5. RuntimeError.

10. Dado el siguiente comando, ¿cuáles de las siguientes clases habilitarán sus assertions?

java -ea -da:com… net.example.LaunchTranslator 

  1. com.example.Translator
  2. java.lang.String
  3. dot.com.Boom
  4. net.example.LaunchTranslator
  5. java.lang.AssertionError

11. Which of the following statements is true?

  1. If assertions are compiled into a source file, and if no flags are included at runtime, assertions will execute by default.
  2. As of Java version 1.4, assertion statements are compiled by default.
  3. With the proper use of runtime arguments, it is possible to instruct the VM to disable assertions for a certain class, and to enable assertions for a certain package, at the same time.
  4. When evaluating command-line arguments, the VM gives -ea flags precedence over -da flags.

12. Which of the following statements is true?

  1. It is sometimes good practice to throw an AssertionError explicitly.
  2. Private getter() and setter() methods should not use assertions to verify arguments.
  3. If an AssertionError is thrown in a try-catch block, the finally block will be bypassed.
  4. It is proper to handle assertion statement failures using a catch (AssertionException ae) block.

13. Dado el siguiente código, cúales de las siguientes afirmaciones son ciertas?

class MoreAsserts{
    static int x = 5;
    public static void main (String[] args){
        assert(doStuff(42));
        if(x<40);
        else assert(false);
    }
    public static boolean doStuff(int arg){
        assert(arg<x++);
        return false;
    }
}
  1. Ninguna de las sentencias asserts son apropiadas.
  2. La sentencia assert en la línea 4 es apropiada.
  3. La sentencia assert en la línea 6 es apropiada.
  4. La sentencia assert en la línea 9 es apropiada.
  5. Las tres sentencias assert son apropiadas.

14. Dado el mismo código de la pregunta 11 y el siguiente comando, ¿cúal de las siguientes afirmaciones es correcta?
java -ea MoreAsserts

  1. Un assertion error es lanzado.
  2. Una excepción assertion es lanzada.
  3. La invocación en la línea de comandos es inválida.
  4. El código se ejecuta sin errores y sin salida.

15. Dado el siguiente código, ¿cuál sería el resultado si en la línea de comandos tecleamos: java Bold?

class Bold{
    public static void main (String[] args){
        Boolean boo = true;
        assert(!boo):"yee ";
        System.out.println("haw ");
    }
}
  1. yee sin errores
  2. haw sin errores
  3. yee haw sin errores
  4. AssertionError incluyendo yee en el mensaje
  5. AssertionError incluyendo haw en el mensaje
  6. AssertionError sin yee ni haw en el mensaje

16. ¿Cuál es el resultado del siguiente código?

public class Test {
    public static void main(String... args) {
        for(int i = 2; i < 4; i++)
            for(int j = 2; j < 4; j++)
                assert i!=j : i;
    }
}
  1. La clase compila y ejecuta, pero no imprime nada.
  2. Se produce un AssertionError y como mensaje se imprime 2.
  3. Se produce un AssertionError y como mensaje se imprime 3.
  4. Se produce un error de compilación.

17. ¿Cúal es el resultado del siguiente código?

public class Test {
    public static void main(String... args) {
        for(int i = 2; i < 4; i++)
           for(int j = 2; j < 4; j++)
	       if(i < j)
                   assert i!=j : i;
	}
}
  1. La clase compila y ejecuta, pero no imprime nada.
  2. Se produce un AssertionError y como mensaje se imprime 2.
  3. Se produce un AssertionError y como mensaje se imprime 3.
  4. Se produce un error de compilación

18. Dado el siguiente código, ¿cúales de las siguientes afirmaciones son ciertas?

public void go(int x) {
    assert (x > 0);
    switch(x) {
    case 2: ;
    default: assert false;
    }
}

private void go2(int x) { assert (x < 0); }
  1. Todas las sentencias asserts tienen usos apropiados.
  2. Solo la primera sentencia assert está usada apropiadamente.
  3. Solo la segunda sentencia assert está usada apropiadamente.
  4. Solo la tercera sentencia assert está usada apropiadamente.
  5. Solo la primera y segunda sentencia assert están usadas apropiadamente.
  6. Solo la primera y tercera sentencia assert están usadas apropiadamente.
  7. Solo la segunda y tercera sentencia assert están usadas apropiadamente.

19. Dado el siguiente código y si se invoca la ejecución primero sin habilitar assertions y luego habilitándolas, ¿cúal sería el resultado?

public class Donkey2 {
    public static void main(String[] args) {
        boolean assertsOn = true;
        assert (assertsOn) : assertsOn = true;
        if(assertsOn) {
            System.out.println(“assert is on”);
        }
    }
}
  1. no output
  2. no output assert is on
  3. assert is on
  4. no output , An Assertion Error is thrown
  5. assert is on , An AssertionError is thrown

20. Given the following code, Which two will produce an AssertionError?

public class test{
    public static void main(String [] a){
        assert a.length== 1;
    }
}
  1. java test
  2. java-ea test
  3. java test file1
  4. java -ea test file1
  5. java-ea test file1file2
  6. java-ea:test test file1

21. Given the following code, what is the result

static void test() throws Error {
    if(true) throw new AssertionError();
    System.out.print("test ");
}
public static void main(String[] args){
    try{ test();}
    catch (Exception ex) { System.out.print("exception "); }
    System.out.print("end ");
}
  1. end
  2. Compilation fails
  3. exception end
  4. exception test end
  5. A Throwable is thrown by main
  6. An Exception is thrown by main

22. Given the following code, which statement is true?

int z=5;
public void stuff1(int x){
assert(x > 0);
switch(x){
case 2: x = 3;
default: assert false;}}

private void stuff2(int y){ assert(y< 0); }
private void stuff3(){ assert(stuff4());}
private boolean stuff4(){ z = 6; return false;}
  1. All of the assert statements are used appropriately.
  2. Only the assert statement on line 8 is used appropriately.
  3. The assert statements on lines 6 and 8 are used appropriately.
  4. The assert statements on lines 3 and 6 are used appropriately.
  5. The assert statements on lines 6 and 9 are used appropriately.
  6. The assert statements on lines 6, 8, and 9 are used appropriately.
  7. The assert statements on lines 3, 6, and 8 are used appropriately

23. Given the following code and the invocation java -source 1.3 Test.java, what is the result?

public class Test {

public static void main(String [] args) {
boolean assert = true;
if(assert) {
System.out.println(”assert is true”);
}
}

}
  1. Compilation fails.
  2. Compilation succeeds with errors.
  3. Compilation succeeds with warnings.
  4. Compilation succeeds without warnings or errors.

24. Given these two following files and the four
command-line invocations:
javac -source 1.3 One.java
javac -source 1.4 One.java
javac -source 1.3 Two.java
javac -source 1.4 Two.java
, what is the result?

class One {
public static void main(String[] args) {
int assert = 0;
}
}
class Two {
public static void main(String[] args) {
assert(false);
}
}
  1. Only one compilation will succeed.
  2. Exactly two compilations will succeed.
  3. Exactly three compilations will succeed.
  4. All four compilations will succeed.
  5. No compiler warnings will be produced.
  6. At least one compiler warning will be produced.

25. What will happen when you attempt to compile and run the following code?

public class AssertTest
    {
        public void methodA(int i)
        {
            assert i >= 0 : methodB();
            System.out.println(i);
        }

        public void methodB()
        {
            System.out.println("The value must not be negative");
        }
        public static void main(String args[])
        {
            AssertTest test = new AssertTest();
            test.methodA(-10);
        }
    }

  1. It will print -10
  2. It will result in Assertion Error showing the message -“The value must not be negative”.
  3. The code will not compile.
  4. None of these.

26. What will be the output of the program?

public class Test
{
    public static void main(String[] args)
    {
        int x = 0;
        assert (x > 0) ? "assertion failed" : "assertion passed" ;
        System.out.println("finished");
    }
}
  1. finished
  2. Compiliation fails.
  3. An AssertionError is thrown and finished is output.
  4. An AssertionError is thrown with the message “assertion failed.”

27. What causes compilation to fail?

public class Test
{
    public void foo()
    {
        assert false;
        assert false;
    }
    public void bar()
    {
        while(true)
        {
            assert false;
        }
        assert false;
    }
}
  1. Line 5
  2. Line 6
  3. Line 12
  4. Line 14

28. What will be the output of the program?

public class Test
{
    public static int y;
    public static void foo(int x)
    {
        System.out.print("foo ");
        y = x;
    }
    public static int bar(int z)
    {
        System.out.print("bar ");
        return y = z;
    }
    public static void main(String [] args )
    {
        int t = 0;
        assert t > 0 : bar(7);
        assert t > 1 : foo(8);
        System.out.println("done ");
    }
}

  1. bar
  2. bar done
  3. foo done
  4. compilations fails

29. What will be the output of the program (when you run with the -ea option) ?

public class Test
{
    public static void main(String[] args)
    {
        int x = 0;
        assert (x > 0) : "assertion failed";
        System.out.println("finished");
    }
}
  1. finished
  2. Compilation fails.
  3. An AssertionError is thrown.
  4. An AssertionError is thrown and finished is output.

30. Which line is an example of an inappropriate use of assertions?

public class Test2
{
    public static int x;
    public static int foo(int y)
    {
        return y * 2;
    }
    public static void main(String [] args)
    {
        int z = 5;
        assert z > 0;
        assert z > 2: foo(z);
        if ( z < 7 )             assert z > 4;

        switch (z)
        {
            case 4: System.out.println("4 ");
            case 5: System.out.println("5 ");
            default: assert z < 10;
        }

        if ( z < 10 )             assert z > 4: z++;
        System.out.println(z);
    }
}
  1. Line 11
  2. Line 12
  3. Line 14
  4. Line 22

Fuentes: Etutorials , Searchcrone , Scjp doc in Scribd , Java2Share , IndiaBix

Anuncios
 
2 comentarios

Publicado por en 24 marzo, 2012 en Preguntas

 

Etiquetas: , , , , , ,

2 Respuestas a “30 preguntas sobre Assertions

  1. Jessica

    16 enero, 2013 at 6:23 pm

    Hola mucho gusto, yo tengo una duda con la pregunta 19.
    de ante mano se que la respuesta es “assert is on” 1 sola vez, mi pregunta es por que no lo imprime si assertsOn es true en las 2 ocasiones???
    Saludos.

     
    • Nendrel

      10 septiembre, 2013 at 8:31 pm

      Buenas Jessica, supongo que llego un poco tarde a tu pregunta, pero para la gente que tenga tu misma duda aquí está la respuesta:

      Como tú dices, la respuesta correcta es la 3. “assert is on” tanto si están activados como si no. Esto es así porque la primera vez (deshabilitados) ignora el assert, entonces assertsOn es true y se imprime el mensaje “assert is on”. Con los asserts habilitados, al ser assertsOn igual a true, la sentencia assert no da error, entonces se imprime el mensaje “assert is on”.

      ¿Seguro que no te lo imprime? Prueba el código con java Donkey2 y java -ea Donkey2. Verás el mismo resultado.

      Saludos!

       

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s

 
A %d blogueros les gusta esto: