working on it ...

Filters

Explore Public Snippets

Sort by

Found 994 snippets matching: unit-test

    public by JKCPR modified Apr 25, 2018  786  0  5  1

    unit testing - mocking server responses with sinonjs

    {
        setUp: function () {
            this.server = sinon.fakeServer.create();
        },
    
        tearDown: function () {
            this.server.restore();
        },
    
        "test should fetch comments from server" : function () {
            this.server.respondWith("GET", "/some/article/comments.json",
                                    [200, { "Content-Type": "application/json" },
                                     '[{ "id": 12, "comment": "Hey there" }]']);
    
            var callback = sinon.spy();
            myLib.getCommentsFor("/some/article", callback);
            this.server.respond();
    
            sinon.assert.calledWith(callback, [{ id: 12, comment: "Hey there" }]));
        }
    }		

    public by cghersi modified May 23, 2014  21894  168  9  4

    How to run unit tests created with MS Visual Studio without installing Visual Studio

    Do you want to run your unit tests on your staging server? Surely you don't want to make your staging environment "dirty" by installing Visual Studio. I'm also not comfortable with installing the Test Agent. And perhaps you don't have the resources to use Visual Studio Online Continuous Integration stuff... It's not a problem of licenses. We don
    1) From C:\Program Files (x86)\Microsoft Visual Studio 12.0\Common7\IDE\CommonExtensions\Microsoft\TestWindow (copy all content of the folder):
    Extensions (folder)
    ActivateApplication.exe
    EntityFramework.dll
    extension.vsixmanifest
    Microsoft.TeamFoundation.TestPlatform.Client.dll
    Microsoft.TestTools.Cpp.targets
    Microsoft.VisualStudio.MSTest.TestWindow.dll
    Microsoft.VisualStudio.TestPlatform.BuildTasks.dll
    Microsoft.VisualStudio.TestPlatform.Client.dll
    Microsoft.VisualStudio.TestPlatform.Common.dll
    Microsoft.VisualStudio.TestPlatform.Core.dll
    Microsoft.VisualStudio.TestPlatform.Fakes.dll
    Microsoft.VisualStudio.TestPlatform.ObjectModel.dll
    Microsoft.VisualStudio.TestPlatform.TestExecutor.Core.dll
    Microsoft.VisualStudio.TestPlatform.Utilities.AppContainer.dll
    Microsoft.VisualStudio.TestPlatform.Utilities.dll
    Microsoft.VisualStudio.TestPlatform.Utilities.PhoneAppContainer.dll
    Microsoft.VisualStudio.TestWindow.Core.dll
    Microsoft.VisualStudio.TestWindow.CppUnitTestExtension.dll
    Microsoft.VisualStudio.TestWindow.dll
    Microsoft.VisualStudio.TestWindow.Interfaces.dll
    Microsoft.VisualStudio.TestWindow.pkgdef
    Microsoft.VisualStudio.TestWindow.VSTest.dll
    msdia120typelib_clr0200.dll
    TestWindowProvideCodeBase.pkgdef
    vstest.console.exe
    vstest.console.exe.config
    vstest.discoveryengine.exe
    vstest.discoveryengine.exe.config
    vstest.discoveryengine.x86.exe
    vstest.discoveryengine.x86.exe.config
    vstest.executionengine.clr20.exe
    vstest.executionengine.clr20.exe.config
    vstest.executionengine.exe
    vstest.executionengine.exe.config
    vstest.executionengine.x86.clr20.exe
    vstest.executionengine.x86.clr20.exe.config
    vstest.executionengine.x86.exe
    vstest.executionengine.x86.exe.config
    
    2) From C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC:
    vcvarsall.bat (put this file into a sufolder named "vc")
    
    3) From C:\Program Files (x86)\Microsoft Visual Studio 12.0\Common7\IDE\PrivateAssemblies:
    Microsoft.VisualStudio.QualityTools.Sqm.dll
    
    4) From C:\Program Files (x86)\Microsoft Visual Studio 12.0\Common7\IDE\ReferenceAssemblies\v2.0:
    Microsoft.VisualStudio.QualityTools.ExecutionCommon.dll
    
    5) For these files you need to use copy command from a DOS prompt, and then copy from c:/tmp to your staging folder: 
    copy C:\Windows\assembly\GAC_MSIL\Microsoft.VisualStudio.QualityTools.Resource\12.0.0.0__b03f5f7f11d50a3a\Microsoft.VisualStudio.QualityTools.Resource.dll c:\tmp
    copy C:\Windows\assembly\GAC_MSIL\Microsoft.VisualStudio.QualityTools.Common\12.0.0.0__b03f5f7f11d50a3a\Microsoft.VisualStudio.QualityTools.Common.dll c:\tmp
    copy C:\Windows\assembly\GAC_MSIL\Microsoft.VisualStudio.QualityTools.Tips.UnitTest.ObjectModel\12.0.0.0__b03f5f7f11d50a3a\Microsoft.VisualStudio.QualityTools.Tips.UnitTest.ObjectModel.dll c:\tmp
    copy C:\Windows\assembly\GAC_MSIL\Microsoft.VisualStudio.QualityTools.UnitTestFramework\10.0.0.0__b03f5f7f11d50a3a\Microsoft.VisualStudio.QualityTools.UnitTestFramework.dll c:\tmp
    

    public by addicttux modified Aug 27, 2015  12006  2  6  0

    TEST: xxx_test.rb

    Unit Testing
    require 'test_helper'
    
    class NombreDeTablaEnSingularTest < ActiveSupport::TestCase
    
      setup do
        @root = users :admin
        @usr  = users :user
        @caracteres_minimo = 
        @caracteres_maximo = 
        @palabra = ''
        @datos_1char          = { forma_de_pago: 'a',                      solo_root_ns: false, usuario_actual: @usr }
        @datos_blanco         = { forma_de_pago: '',                       solo_root_ns: false, usuario_actual: @usr }
        @datos_blanco_ambos   = { forma_de_pago: " #{@palabra} ",          solo_root_ns: false, usuario_actual: @usr }
        @datos_blanco_final   = { forma_de_pago: "#{@palabra} ",           solo_root_ns: false, usuario_actual: @usr }
        @datos_blanco_inicial = { forma_de_pago: " #{@palabra}",           solo_root_ns: false, usuario_actual: @usr }
        @datos_excedido       = { forma_de_pago: 'a'*@caracteres_maximo*2, solo_root_ns: false, usuario_actual: @usr }
        @datos_maximo         = { forma_de_pago: 'a'*@caracteres_maximo,   solo_root_ns: false, usuario_actual: @usr }
        @datos_minimo         = { forma_de_pago: 'a'*@caracteres_minimo,   solo_root_ns: false, usuario_actual: @usr }
        @datos_minusculas     = { forma_de_pago: @palabra.upcase,          solo_root_ns: false, usuario_actual: @usr }
        @datos_nulo           = { forma_de_pago: nil,                      solo_root_ns: false, usuario_actual: @usr }
        @datos_root           = { forma_de_pago: 'segundo',                solo_root_ns: true,  usuario_actual: @root }
        @datos_user           = { forma_de_pago: 'valor',                  solo_root_ns: false }
        @duplicado            = { forma_de_pago: '',                       solo_root_ns: false, usuario_actual: @usr }
      end
    
      # +-------------------------+
      # | Pruebas para New/Create |
      # +-------------------------+
    
      test 'Prueba #XXX-U-001: Probando la creación de ______ [hmjr]' do
        tut = NombreDeTablaEnSingular.create @datos_user
        assert tut.valid?, tut.errors.messages.to_yaml
      end
    
      test 'Prueba #XXX-U-002: Probando que no guarde ______ en blanco [hmjr]' do
        tut = NombreDeTablaEnSingular.create @datos_blanco
        refute tut.valid?, 'Se guardó en blanco'
      end
    
      test 'Prueba #XXX-U-003: Probando que no guarde ______ nil [hmjr]' do
        tut = NombreDeTablaEnSingular.create @datos_nulo
        refute tut.valid?, 'Se guardó siendo nil'
      end
    
      test 'Prueba #XXX-U-004: Probando que no guarde ______ menores al mínimo de caracteres [hmjr]' do
        tut = NombreDeTablaEnSingular.create @datos_1char
        refute tut.valid?, 'Se guardó siendo menor al mínimo de caracteres'
      end
    
      test 'Prueba #XXX-U-005: Probando que guarde ______ igual al mínimo de caracteres [hmjr]' do
        tut = NombreDeTablaEnSingular.create @datos_minimo
        assert tut.valid?, 'No se guardo palabra igual al mínimo de caracteres'
      end
    
      test 'Prueba #XXX-U-006: Probando que guarde ______ igual al máximo de caracteres [hmjr]' do
        tut = NombreDeTablaEnSingular.create @datos_maximo
        assert tut.valid?, 'No se guardo palabra igual al maximo de caracteres'
      end
    
      test 'Prueba #XXX-U-007: Prueba que no se guarde ______ mayor del máximo de caracteres permitidos [hmjr]' do
        tut = NombreDeTablaEnSingular.create @datos_excedido
        refute tut.valid?, 'Se guardo palabra de mas caracteres que los permitidos'
      end
    
      test 'Prueba #XXX-U-008: Prueba que elimine el espacio inicial [hmjr]' do
        tut = NombreDeTablaEnSingular.create @datos_blanco_inicial
        assert_equal tut.forma_de_pago, @palabra, 'No eliminó el espacio inicial'
      end
    
      test 'Prueba #XXX-U-009: Prueba que elimine espacios finales [hmjr]' do
        tut = NombreDeTablaEnSingular.create @datos_blanco_final
        assert_equal tut.forma_de_pago, @palabra, 'No eliminó los espacios finales'
      end
    
      test 'Prueba #XXX-U-010: Prueba que elimine espacios iniciales y finales [hmjr]' do
        tut = NombreDeTablaEnSingular.create @datos_blanco_ambos
        assert_equal tut.forma_de_pago, @palabra, 'No eliminó los espacios alrededor del texto'
      end
    
      test 'Prueba #XXX-U-011: Prueba que se guarde en minúsculas [hmjr]' do
        tut = NombreDeTablaEnSingular.create @datos_minusculas
        assert_equal tut.forma_de_pago, @palabra, 'No guardó el texto en minúsculas'
      end
    
      test 'Prueba #XXX-U-012: Prueba que detecte contenido duplicado [hmjr]' do
        original = NombreDeTablaEnSingular.first.forma_de_pago
        @duplicado[:forma_de_pago] = original
        tut = NombreDeTablaEnSingular.create @duplicado
        refute tut.valid?, 'No detectó duplicidad'
      end
    
    
      # +----------------------+
      # | Pruebas para Destroy |
      # +----------------------+
    
      test 'Prueba #XXX-U-013: No debe de poder eliminar sin ser usuario registrado [hmjr]' do
        tut = NombreDeTablaEnSingular.create @datos_user
        antes = NombreDeTablaEnSingular.count
        tut.destroy
        assert_equal antes, NombreDeTablaEnSingular.count, 'Borró pese a no estar registrado'
      end
    
      test 'Prueba #XXX-U-014: Elimina ______, el usuario no es root, solo_root_ns = false, no tiene dependientes [hmjr]' do
        tut = NombreDeTablaEnSingular.create @datos_user
        tut.usuario_actual = @usr
        antes = NombreDeTablaEnSingular.count
        tut.destroy
        refute_equal antes, NombreDeTablaEnSingular.count, 'No se borró y no tiene teléfonos dependientes'
      end
    
      test 'Prueba #XXX-U-015: Elimina ______, el usuario no es root, solo_root_ns = false, TIENE dependientes [hmjr]' do
    #    tid = NombreDeTablaEnSingular.first
    #    dir = Directorio.create razon_fiscal: 'borrame s.a. de c.v.', razon_comercial: 'borrame', sobrenombre: 'borrame'
    #    TablaRelacionada.create tipo_forma_pago: tid, directorio: dir, solo_root_ns: false
    #    antes = NombreDeTablaEnSingular.count
    #    tid.usuario_actual = @usr
    #    tid.destroy
    #    assert_equal antes, NombreDeTablaEnSingular.count, 'Se eliminó pese a que tiene dependientes'
      end
    
    
      test 'Prueba #XXX-U-016: Elimina ______, el usuario no es root, solo_root_ns = true [hmjr]' do
        tut = NombreDeTablaEnSingular.create @datos_root
        tut.usuario_actual = @usr
        antes = NombreDeTablaEnSingular.count
        tut.destroy
        assert_equal antes, NombreDeTablaEnSingular.count, 'Pudo borrar registro cuando solo root debería'
      end
    
      test 'Prueba #XXX-U-017: Elimina ______, el usuario es ROOT, solo_root_ns = false [hmjr]' do
        tut = NombreDeTablaEnSingular.create @datos_user
        tut.usuario_actual = @root
        antes = NombreDeTablaEnSingular.count
        tut.destroy
        refute_equal antes, NombreDeTablaEnSingular.count, 'Root no pudo borrar un registro no exclusivo'
      end
    
      test 'Prueba #XXX-U-018: Elimina ______, el usuario es ROOT, solo_root_ns = true [hmjr]' do
        tut = NombreDeTablaEnSingular.create @datos_root
        antes = NombreDeTablaEnSingular.count
        tut.destroy
        refute_equal antes, NombreDeTablaEnSingular.count, 'Root no pudo borrar un registro exclusivo'
      end
    
      # +---------------------------------------+
      # | Pruebas para Edit para usuario normal |
      # +---------------------------------------+
    
      test 'Prueba #XXX-U-019: Probando la edición de ______ con usuario no logeado [hmjr]' do
        tut = NombreDeTablaEnSingular.last
        tut.update @datos_user
        refute tut.save, tut.errors.messages.to_yaml
      end
    
      test 'Prueba #XXX-U-020: Probando la edición de ______ con usuario logeado [hmjr]' do
        @datos_user[:usuario_actual] = @usr
        tut = NombreDeTablaEnSingular.first
        tut.update @datos_user
        assert tut.save, tut.errors.messages.to_yaml
      end
    
      test 'Prueba #XXX-U-021: Probando que no edite ______ en blanco [hmjr]' do
        tut = NombreDeTablaEnSingular.first
        tut.update @datos_blanco
        refute tut.valid?, 'Se guardó en blanco'
      end
    
      test 'Prueba #XXX-U-022: Probando que no edite ______ nil [hmjr]' do
        tut = NombreDeTablaEnSingular.first
        tut.update @datos_nulo
        refute tut.valid?, 'Se guardó siendo nil'
      end
    
      test 'Prueba #XXX-U-023: Probando que no edite ______ menores al mínimo de caracteres [hmjr]' do
        tut = NombreDeTablaEnSingular.first
        tut.update @datos_1char
        refute tut.valid?, 'Se guardó siendo menor al mínimo de caracteres'
      end
    
      test 'Prueba #XXX-U-024: Probando que guarde ______ siendo igual al mínimo de caracteres [hmjr]' do
        tut = NombreDeTablaEnSingular.first
        tut.update @datos_minimo
        assert tut.valid?, 'No se guardo palabra igual al mínimo de caracteres'
      end
    
      test 'Prueba #XXX-U-025: Probando que guarde ______ igual al máximo de caracteres [hmjr]' do
        tut = NombreDeTablaEnSingular.first
        tut.update @datos_maximo
        assert tut.valid?, 'No se guardo palabra igual al máximo de caracteres'
      end
    
      test 'Prueba #XXX-U-026: Prueba que no se guarde ______ mayor al máximo de caracteres [hmjr]' do
        tut = NombreDeTablaEnSingular.first
        tut.update @datos_excedido
        refute tut.valid?, 'Se guardo palabra mayor al máximo de caracteres'
      end
    
      test 'Prueba #XXX-U-027: Prueba que elimine el espacio inicial [hmjr]' do
        tut = NombreDeTablaEnSingular.first
        tut.update @datos_blanco_inicial
        assert_equal tut.forma_de_pago, @palabra, 'No eliminó el espacio inicial'
      end
    
      test 'Prueba #XXX-U-028: Prueba que elimine espacios finales [hmjr]' do
        tut = NombreDeTablaEnSingular.first
        tut.update @datos_blanco_final
        assert_equal tut.forma_de_pago, @palabra, 'No eliminó los espacios finales'
      end
    
      test 'Prueba #XXX-U-029: Prueba que elimine espacios iniciales y finales [hmjr]' do
        tut = NombreDeTablaEnSingular.first
        tut.update @datos_blanco_ambos
        assert_equal tut.forma_de_pago, @palabra, 'No eliminó los espacios alrededor del texto'
      end
    
      test 'Prueba #XXX-U-030: Prueba que se guarde en minúsculas [hmjr]' do
        tut = NombreDeTablaEnSingular.first
        tut.update @datos_minusculas
        assert_equal tut.forma_de_pago, @palabra, 'No guardó el texto en minúsculas'
      end
    
      test 'Prueba #XXX-U-031: Prueba que detecte contenido duplicado [hmjr]' do
        tut = NombreDeTablaEnSingular.first
        tut.update forma_de_pago: NombreDeTablaEnSingular.last.forma_de_pago, usuario_actual: @usr
        refute tut.valid?, 'No detectó duplicidad'
      end
    
      test 'Prueba #XXX-U-032: Prueba que NO pueda editar si solo_root_ns es true [hmjr]' do
        tut = NombreDeTablaEnSingular.create forma_de_pago: @palabra, solo_root_ns: true, usuario_actual: @usr
        cam = NombreDeTablaEnSingular.find tut.id
        cam.forma_de_pago = 'cambiado'
        cam.usuario_actual = @usr
        refute cam.save, 'No detectó que solo root lo puede modificar'
      end
    
      # +-------------------------------------+
      # | Pruebas para Edit para usuario root |
      # +-------------------------------------+
    
      test 'Prueba #XXX-U-033: Probando la edición de ______ con usuario logeado [hmjr]' do
        @usr = @root
        tut = NombreDeTablaEnSingular.last
        tut.update @datos_root
        assert tut.save, tut.errors.messages.to_yaml
      end
    
      test 'Prueba #XXX-U-034: Probando que no edite ______ en blanco [hmjr]' do
        tut = NombreDeTablaEnSingular.last
        tut.update @datos_blanco
        refute tut.valid?, 'Se guardó en blanco'
      end
    
      test 'Prueba #XXX-U-035: Probando que no edite ______ nil [hmjr]' do
        tut = NombreDeTablaEnSingular.last
        tut.update @datos_nulo
        refute tut.valid?, 'Se guardó siendo nil'
      end
    
      test 'Prueba #XXX-U-036: Probando que no edite ______ menores al mínimo de caracteres [hmjr]' do
        tut = NombreDeTablaEnSingular.last
        tut.update @datos_1char
        refute tut.valid?, 'Se guardó siendo menor al mínimo de caracteres'
      end
    
      test 'Prueba #XXX-U-037: Probando que guarde ______ igual al mínimo de caracteres [hmjr]' do
        tut = NombreDeTablaEnSingular.last
        tut.update @datos_minimo
        assert tut.valid?, 'No se guardo palabra igual al mínimo de caracteres'
      end
    
      test 'Prueba #XXX-U-038: Probando que guarde ______ igual al máximo de caracteres [hmjr]' do
        tut = NombreDeTablaEnSingular.last
        tut.update @datos_maximo
        assert tut.valid?, 'No se guardo palabra igual al máximo de caracteres'
      end
    
      test 'Prueba #XXX-U-039: Prueba que no se guarde ______ mayor al máximo de caracteres [hmjr]' do
        tut = NombreDeTablaEnSingular.last
        tut.update @datos_excedido
        refute tut.valid?, 'Se guardo palabra mayor al máximo de caracteres'
      end
    
      test 'Prueba #XXX-U-040: Prueba que elimine el espacio inicial [hmjr]' do
        tut = NombreDeTablaEnSingular.last
        tut.update @datos_blanco_inicial
        assert_equal tut.forma_de_pago, @palabra, 'No eliminó el espacio inicial'
      end
    
      test 'Prueba #XXX-U-041: Prueba que elimine espacios finales [hmjr]' do
        tut = NombreDeTablaEnSingular.last
        tut.update @datos_blanco_final
        assert_equal tut.forma_de_pago, @palabra, 'No eliminó los espacios finales'
      end
    
      test 'Prueba #XXX-U-042: Prueba que elimine espacios iniciales y finales [hmjr]' do
        tut = NombreDeTablaEnSingular.last
        tut.update @datos_blanco_ambos
        assert_equal tut.forma_de_pago, @palabra, 'No eliminó los espacios alrededor del texto'
      end
    
      test 'Prueba #XXX-U-043: Prueba que se guarde en minúsculas [hmjr]' do
        tut = NombreDeTablaEnSingular.last
        tut.update @datos_minusculas
        assert_equal tut.forma_de_pago, @palabra, 'No guardó el texto en minúsculas'
      end
    
      test 'Prueba #XXX-U-044: Prueba que detecte contenido duplicado [hmjr]' do
        tut = NombreDeTablaEnSingular.last
        tut.update forma_de_pago: NombreDeTablaEnSingular.first.forma_de_pago, usuario_actual: @root
        refute tut.valid?, 'No detectó duplicidad'
      end
    
      test 'Prueba #XXX-U-045: Prueba que pueda editar si solo_root_ns es true [hmjr]' do
        tut = NombreDeTablaEnSingular.create forma_de_pago: @palabra, solo_root_ns: true, usuario_actual: @root
        cam = NombreDeTablaEnSingular.find tut.id
        cam.forma_de_pago = 'cambiado'
        cam.usuario_actual = @root
        assert cam.save, 'No detectó que solo root lo puede modificar'
      end
    
    end
    
    #------------------------------------------------------------------------------
    # NombreDeTablaEnSingular
    #
    # Name          SQL Type             Null    Default Primary
    # ------------- -------------------- ------- ------- -------
    # id            int(11)              false           true
    # forma_de_pago varchar(10)          false           false
    # solo_root_ns  tinyint(1)           false   0       false
    # lock_version  int(11)              false   0       false
    # created_at    datetime             false           false
    # updated_at    datetime             false           false
    #
    #------------------------------------------------------------------------------
    

    public by lauhin modified Jul 22, 2015  2809  0  6  0

    Unit test equals and hashcode

    how to unit test equals and hashcode from a class in java
    //maven dependency
    <dependency>
        <groupId>nl.jqno.equalsverifier</groupId>
        <artifactId>equalsverifier</artifactId>
        <version>1.1.3</version>
    </dependency>
    
    //unit test method
    @Test
    public void testEqualsAndHashcode() {
        EqualsVerifier.forClass(ModelClassToTest.class).usingGetClass().suppress(Warning.NONFINAL_FIELDS).verify();
    }                       

    public by lauhin modified Aug 23, 2015  2386  2  3  0

    Unit test private constructor in java

    Unit test private constructor in java: private_constructor_test.java
    @Test
    public void privateConstructorTest() throws Exception {
        Constructor<MyClass> constructor = MyClass.class.getDeclaredConstructor();
        assertEquals(constructor.isAccessible(), false);
        constructor.setAccessible(true);
        constructor.newInstance((Object[]) null);
    }
    
    

    public by qxshower modified Apr 27, 2015  1265  0  6  0

    AssemblyInitialize

    This method perform a one-time initialization across all unit tests in the assembly.
    using EnvDTE;
    using Microsoft.VisualStudio.Shell.Interop;
    using Microsoft.VisualStudio.TestTools.UnitTesting;
    using Microsoft.VSSDK.Tools.VsIdeTesting;
    using SteveCadwallader.CodeMaid.Integration;
    using SteveCadwallader.CodeMaid.Properties;
    using System;
    using System.ComponentModel.Design;
    
    /// <summary>
    /// Gets the <see cref="CodeMaidPackage" />.
    /// </summary>
    public static CodeMaidPackage Package { get; private set; }
    /// <summary>
    /// Gets the test project.
    /// </summary>
    public static Project Project { get; private set; }
    
    /// <summary>
    /// This method perform a one-time initialization across all unit tests in the assembly.
    /// </summary>
    /// <param name="testContext">The test context.</param>
    [AssemblyInitialize]
    public static void AssemblyInitialize(TestContext testContext)
    {
        UIThreadInvoker.Invoke(new Action(() =>
        {
            // Load the package into the shell.
            IVsShell shellService = (IVsShell)VsIdeTestHostContext.ServiceProvider.GetService(typeof(SVsShell));
            Guid packageGuid = new Guid(GuidList.GuidCodeMaidPackageString);
            IVsPackage package;
    
            shellService.IsPackageLoaded(ref packageGuid, out package);
    
            if (package == null)
            {
                shellService.LoadPackage(ref packageGuid, out package);
            }
    
            Assert.IsTrue(package is CodeMaidPackage);
            Package = (CodeMaidPackage)package;
    
            // Generate an empty solution.
            const string projectName = "IntegrationTests";
            TestUtils.CreateEmptySolution(testContext.TestDir, projectName);
            Assert.AreEqual(0, TestUtils.ProjectCount());
    
            // Generate an empty project.
            TestUtils.CreateProjectFromTemplate(projectName, "ConsoleApplication.zip", "CSharp");
            Assert.AreEqual(1, TestUtils.ProjectCount());
    
            // Capture the project for later use.
            Project = Package.IDE.Solution.Projects.Item(1);
            Assert.IsNotNull(Project);
            Assert.AreEqual(Project.Name, projectName);
        }));
    }            

    public by Github modified Jan 20, 2014  1766  0  4  0

    Parameterizing Unit Tests

    Parameterizing Unit Tests: parameterized.py
    import unittest
    
    l = [["foo", "a", "a",], ["bar", "a", "b"], ["lee", "b", "b"]]
    
    class TestSequense(unittest.TestCase):
        pass
    
    def test_generator(a, b):
        def test(self):
            self.assertEqual(a,b)
        return test
    
    if __name__ == '__main__':
        for t in l:
            test_name = 'test_%s' % t[0]
            test = test_generator(t[1], t[2])
            setattr(TestSequense, test_name, test)
        unittest.main()
    
    

    public by TristinDavis modified Aug 9, 2016  1202  0  4  0

    Class to do Unit Test with TypeScript and TSTestAdapter

    Class to do Unit Test with TypeScript and TSTestAdapter: UnitTest.ts
    class Assert
    {
        public static AreEqual<T>(expected: T, actual: T, message: string = ""): void
        {
            if (expected !== actual)
            {
                throw "Assert.AreEqual failed. "
                    + "Expected: <" + expected + ">. "
                    + "Actual: <" + actual + ">. "
                    + message;
            }
        }
    
        public static AreNotEqual<T>(notExpected: T, actual: T, message: string = ""): void
        {
            if (notExpected === actual)
            {
                throw "Assert.AreNotEqual failed. "
                    + "Expected any value except: <" + notExpected + ">. "
                    + "Actual: <" + actual + ">. "
                    + message;
            }
        }
    
        public static AreNotSame<T>(notExpected: T, actual: T, message: string = ""): void
        {
            if (typeof (notExpected) !== "object"
                || typeof (actual) !== "object")
            {
                throw "Assert.AreSame failed. Do not pass value types to AreSame(). Consider using AreEqual()."
            }
    
            if (notExpected === actual)
            {
                throw "Assert.AreNotSame failed. " + message;
            }
        }
    
        public static AreSequenceEqual<T>(expected: T[], actual: T[], equals?: (x, y) => boolean, message: string = ""): void
        {
            if (expected === null || actual === null)
            {
                throw "Assert.AreSequenceEqual failed. Do not pass null values to arrays. " + message;
            }
    
            if (expected === actual)
            {
                return;
            }
    
            if (expected.length !== actual.length)
            {
                throw "Assert.AreSequenceEqual failed. Length mismatch. "
                    + "Expected: <" + expected.length + ">. "
                    + "Actual: <" + actual.length + ">. "
                    + message;
            }
    
            if (!equals)
                equals = (x, y) => x == y;
    
            for (var i = 0, n = expected.length; i < n; i++)
            {
                if (!equals(expected[i], actual[i]))
                {
                    throw "Assert.AreSequenceEqual failed. "
                        + "Expected: <" + expected[i] + ">. Actual: <" + actual[i] + ">."
                        + message;
                }
            }
        }
    
        public static Fail(message: string = ""): void
        {
            throw "Assert.Fail failed. " + message;
        }
    
        // TODO: Implementation
        public static Inconclusive(message: string = ""): void
        {
            throw "NotImplementedException";
        }
    
        public static IsFalse(actual: boolean, message: string = ""): void
        {
            if (actual !== false)
            {
                throw "Assert.IsFalse failed. " + message;
            }
        }
    
        public static IsInstanceOfType(actual: any, expectedType: Function, message: string = ""): void
        {
            if (!(actual instanceof expectedType))
            {
                var expectedTypeName = /^function\s*([^(]*)/i.exec(expectedType + "")[1].toLocaleLowerCase();
                var actualTypeName = /^function\s*([^(]*)/i.exec(actual.constructor + "")[1].toLocaleLowerCase();
    
                throw "Assert.IsInstanceOfType failed. "
                    + "Expected type: <" + expectedTypeName + ">. "
                    + "Actual type: <" + actualTypeName + ">. "
                    + message;
            }
        }
    
        public static IsNotInstanceOfType(actual: any, wrongType: Function, message: string = ""): void
        {
            if (actual instanceof wrongType)
            {
                var wrongTypeName = /^function\s*([^(]*)/i.exec(wrongType + "")[1].toLocaleLowerCase();
                var actualTypeName = /^function\s*([^(]*)/i.exec(actual.constructor + "")[1].toLocaleLowerCase();
                
                throw "Assert.IsNotInstanceOfType failed. "
                    + "Expected any type except: <" + wrongTypeName + ">. "
                    + "Actual type: <" + actualTypeName + ">. "
                    + message;
            }
        }
    
        public static IsNotNull(actual: boolean, message: string = ""): void
        {
            if (actual === null)
            {
                throw "Assert.IsNotNull failed. " + message;
            }
        }
    
        public static IsNull(actual: boolean, message: string = ""): void
        {
            if (actual !== null)
            {
                throw "Assert.IsNull failed. " + message;
            }
        }
    
        public static IsTrue(actual: boolean, message: string = ""): void
        {
            if (actual !== true)
            {
                throw "Assert.IsTrue failed. " + message;
            }
        }
    
        public static Throws(fn: () => void, message: string = ""): void
        {
            var result = false;
    
            try
            {
                fn();
            }
            catch (ex)
            {
                result = true;
            }
    
            if (!result)
                throw "Assert.Throws failed. " + message;
        }
    }
    
    

    public by davis modified Aug 9, 2016  1062  0  4  0

    Class to do Unit Test with TypeScript and TSTestAdapter

    Class to do Unit Test with TypeScript and TSTestAdapter: UnitTest.ts
    class Assert
    {
        public static AreEqual<T>(expected: T, actual: T, message: string = ""): void
        {
            if (expected !== actual)
            {
                throw "Assert.AreEqual failed. "
                    + "Expected: <" + expected + ">. "
                    + "Actual: <" + actual + ">. "
                    + message;
            }
        }
    
        public static AreNotEqual<T>(notExpected: T, actual: T, message: string = ""): void
        {
            if (notExpected === actual)
            {
                throw "Assert.AreNotEqual failed. "
                    + "Expected any value except: <" + notExpected + ">. "
                    + "Actual: <" + actual + ">. "
                    + message;
            }
        }
    
        public static AreNotSame<T>(notExpected: T, actual: T, message: string = ""): void
        {
            if (typeof (notExpected) !== "object"
                || typeof (actual) !== "object")
            {
                throw "Assert.AreSame failed. Do not pass value types to AreSame(). Consider using AreEqual()."
            }
    
            if (notExpected === actual)
            {
                throw "Assert.AreNotSame failed. " + message;
            }
        }
    
        public static AreSequenceEqual<T>(expected: T[], actual: T[], equals?: (x, y) => boolean, message: string = ""): void
        {
            if (expected === null || actual === null)
            {
                throw "Assert.AreSequenceEqual failed. Do not pass null values to arrays. " + message;
            }
    
            if (expected === actual)
            {
                return;
            }
    
            if (expected.length !== actual.length)
            {
                throw "Assert.AreSequenceEqual failed. Length mismatch. "
                    + "Expected: <" + expected.length + ">. "
                    + "Actual: <" + actual.length + ">. "
                    + message;
            }
    
            if (!equals)
                equals = (x, y) => x == y;
    
            for (var i = 0, n = expected.length; i < n; i++)
            {
                if (!equals(expected[i], actual[i]))
                {
                    throw "Assert.AreSequenceEqual failed. "
                        + "Expected: <" + expected[i] + ">. Actual: <" + actual[i] + ">."
                        + message;
                }
            }
        }
    
        public static Fail(message: string = ""): void
        {
            throw "Assert.Fail failed. " + message;
        }
    
        // TODO: Implementation
        public static Inconclusive(message: string = ""): void
        {
            throw "NotImplementedException";
        }
    
        public static IsFalse(actual: boolean, message: string = ""): void
        {
            if (actual !== false)
            {
                throw "Assert.IsFalse failed. " + message;
            }
        }
    
        public static IsInstanceOfType(actual: any, expectedType: Function, message: string = ""): void
        {
            if (!(actual instanceof expectedType))
            {
                var expectedTypeName = /^function\s*([^(]*)/i.exec(expectedType + "")[1].toLocaleLowerCase();
                var actualTypeName = /^function\s*([^(]*)/i.exec(actual.constructor + "")[1].toLocaleLowerCase();
    
                throw "Assert.IsInstanceOfType failed. "
                    + "Expected type: <" + expectedTypeName + ">. "
                    + "Actual type: <" + actualTypeName + ">. "
                    + message;
            }
        }
    
        public static IsNotInstanceOfType(actual: any, wrongType: Function, message: string = ""): void
        {
            if (actual instanceof wrongType)
            {
                var wrongTypeName = /^function\s*([^(]*)/i.exec(wrongType + "")[1].toLocaleLowerCase();
                var actualTypeName = /^function\s*([^(]*)/i.exec(actual.constructor + "")[1].toLocaleLowerCase();
                
                throw "Assert.IsNotInstanceOfType failed. "
                    + "Expected any type except: <" + wrongTypeName + ">. "
                    + "Actual type: <" + actualTypeName + ">. "
                    + message;
            }
        }
    
        public static IsNotNull(actual: boolean, message: string = ""): void
        {
            if (actual === null)
            {
                throw "Assert.IsNotNull failed. " + message;
            }
        }
    
        public static IsNull(actual: boolean, message: string = ""): void
        {
            if (actual !== null)
            {
                throw "Assert.IsNull failed. " + message;
            }
        }
    
        public static IsTrue(actual: boolean, message: string = ""): void
        {
            if (actual !== true)
            {
                throw "Assert.IsTrue failed. " + message;
            }
        }
    
        public static Throws(fn: () => void, message: string = ""): void
        {
            var result = false;
    
            try
            {
                fn();
            }
            catch (ex)
            {
                result = true;
            }
    
            if (!result)
                throw "Assert.Throws failed. " + message;
        }
    }
    
    

    public by msdn modified Jan 12, 2015  1617  0  6  0

    AssemblyCleanup: This method is called after launching the unit tests that are in this assembly

    This method is called after launching the unit tests that are in this assembly
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    using Microsoft.VisualStudio.TestTools.UnitTesting;
    using MyEvents.Domain.Entities;
    
    /// <summary>
    /// This method is called after launching the unit tests that are in this assembly
    /// </summary>
    [AssemblyCleanup]
    public static void AssemblyCleanup()
    {
        using (var context = new MyEventsContext())
        {
            DeleteAllOrganizers(context);
    
            Assert.IsTrue(context.Organizers.Count() == 0);
            Assert.IsTrue(context.Attendees.Count() == 0);
            Assert.IsTrue(context.EventDefinitions.Count() == 0);
            Assert.IsTrue(context.Sessions.Count() == 0);
            Assert.IsTrue(context.Materials.Count() == 0);
            Assert.IsTrue(context.Comments.Count() == 0);
        }
    }
    • Public Snippets
    • Channels Snippets