Ziele Untersuchung
mit Columbo Integrität von
Datenbanken Interaktion und
Portierbarkeit Ergonomie der
Schnittstellen

Angebot Produkte Projekt Beratung

Mittel Analytik Modellierung Sprachen Algebra Logik Hardware Denken Kreativität

Zusammenhänge Gesellschaft Wirtschaft Branche Firma


products/Sources/formale Sprachen/Java/Openjdk/test/jdk/java/sql/testng/test/sql/ (Sun/Oracle ^©) Datei vom 13.11.2022 mit Größe 10 kB

Quelle TimeTests.java Sprache: JAVA

/*
* Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package test.sql;

import java.sql.Time;
import java.time.LocalTime;
import static org.testng.Assert.*;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;
import util.BaseTest;

public class TimeTests extends BaseTest {

    /*
     * Validate an IllegalArgumentException is thrown for calling getYear
     */
    @Test(expectedExceptions = IllegalArgumentException.class)
    public void test01() {
        Time t = Time.valueOf("08:30:59");
        t.getYear();
    }

    /*
     * Validate an IllegalArgumentException is thrown for calling getMonth
     */
    @Test(expectedExceptions = IllegalArgumentException.class)
    public void test02() {
        Time t = Time.valueOf("08:30:59");
        t.getMonth();
    }

    /*
     * Validate an IllegalArgumentException is thrown for calling getDay
     */
    @Test(expectedExceptions = IllegalArgumentException.class)
    public void test03() {
        Time t = Time.valueOf("08:30:59");
        t.getDay();
    }

    /**
     * Validate an IllegalArgumentException is thrown for calling getDate
     */
    @Test(expectedExceptions = IllegalArgumentException.class)
    public void test04() {
        Time t = Time.valueOf("08:30:59");
        t.getDate();
    }

    /*
     * Validate an IllegalArgumentException is thrown for calling setYear
     */
    @Test(expectedExceptions = IllegalArgumentException.class)
    public void test05() {
        Time t = Time.valueOf("08:30:59");
        t.setYear(8);
    }

    /*
     * Validate an IllegalArgumentException is thrown for calling setMonth
     */
    @Test(expectedExceptions = IllegalArgumentException.class)
    public void test06() {
        Time t = Time.valueOf("08:30:59");
        t.setMonth(8);
    }

    /*
     * Validate an IllegalArgumentException is thrown for calling setDate
     */
    @Test(expectedExceptions = IllegalArgumentException.class)
    public void test07() {
        Time t = Time.valueOf("08:30:59");
        t.setDate(30);
    }

    /*
     * Validate an IllegalArgumentException is thrown for calling getDate
     */
    @Test(expectedExceptions = IllegalArgumentException.class)
    public void test08() {
        Time t = Time.valueOf("08:30:59");
        t.getDate();
    }

    /*
     * Validate that a Time made from a toLocalTime() LocalTime are equal
     */
    @Test
    public void test09() {
        Time t = Time.valueOf("08:30:59");
        Time t2 = Time.valueOf(t.toLocalTime());
        assertTrue(t.equals(t2), "Error t != t2");
    }

    /*
     * Validate that a Time LocalTime value, made from a LocalTime are equal
     */
    @Test
    public void test10() {
        LocalTime lt = LocalTime.of(8, 30, 59);
        Time t = Time.valueOf(lt);
        System.out.println("lt=" + lt + ",t=" + t.toLocalTime());
        assertTrue(lt.equals(t.toLocalTime()),
                "Error LocalTime values are not equal");
    }

    /*
     * Validate an NPE occurs when a null LocalDate is passed to valueOf
     */
    @Test(expectedExceptions = NullPointerException.class)
    public void test11() throws Exception {
        LocalTime ld = null;
        Time.valueOf(ld);
    }

    /*
     * Validate an UnsupportedOperationException occurs when toInstant() is
     * called
     */
    @Test(expectedExceptions = UnsupportedOperationException.class)
    public void test12() throws Exception {
        Time t = new Time(System.currentTimeMillis());
        t.toInstant();
    }

    /*
     * Validate that two Time objects are equal when one is created from the
     * toString() of the other and that the correct value is returned from
     * toString()
     */
    @Test(dataProvider = "validTimeValues")
    public void test13(String time, String expected) {
        Time t1 = Time.valueOf(time);
        Time t2 = Time.valueOf(t1.toString());
        assertTrue(t1.equals(t2) && t2.equals(t1)
                && t1.toString().equals(expected), "Error t1 != t2");
    }

    /*
     * Validate that two Time values one created using valueOf and another via a
     * constructor are equal
     */
    @Test
    public void test14() {
        Time t = Time.valueOf("08:30:59");
        Time t2 = new Time(8, 30, 59);
        assertTrue(t.equals(t2) && t2.equals(t), "Error t != t2");
    }

    /*
     * Validate that two Time values one created using valueOf and another via a
     * constructor are equal
     */
    @Test
    public void test15() {
        Time t = Time.valueOf("08:30:59");
        Time t2 = new Time(t.getTime());
        assertTrue(t.equals(t2) && t2.equals(t), "Error t != t2");
    }

    /*
     * Validate an IllegalArgumentException is thrown for an invalid Time string
     */
    @Test(dataProvider = "invalidTimeValues",
            expectedExceptions = IllegalArgumentException.class)
    public void test16(String time) throws Exception {
        Time.valueOf(time);
    }

    /*
     * Validate that Time.after() returns false when same date is compared
     */
    @Test
    public void test17() {
        Time t = Time.valueOf("08:30:59");
        assertFalse(t.after(t), "Error t.after(t) = true");
    }

    /*
     * Validate that Time.after() returns true when later date is compared to
     * earlier date
     */
    @Test
    public void test18() {
        Time t = Time.valueOf("08:30:59");
        Time t2 = new Time(System.currentTimeMillis());
        assertTrue(t2.after(t), "Error t2.after(t) = false");
    }

    /*
     * Validate that Time.after() returns false when earlier date is compared to
     * itself
     */
    @Test
    public void test19() {
        Time t = Time.valueOf("08:30:59");
        Time t2 = new Time(t.getTime());
        assertFalse(t.after(t2), "Error t.after(t2) = true");
        assertFalse(t2.after(t), "Error t2.after(t) = true");
    }

    /*
     * Validate that Time.before() returns false when same date is compared
     */
    @Test
    public void test20() {
        Time t = Time.valueOf("08:30:59");
        assertFalse(t.before(t), "Error t.before(t) = true");
    }

    /*
     * Validate that Time.before() returns true when earlier date is compared to
     * later date
     */
    @Test
    public void test21() {
        Time t = Time.valueOf("08:30:59");
        Time t2 = new Time(System.currentTimeMillis());
        assertTrue(t.before(t2), "Error t.before(t2) = false");
    }

    /*
     * Validate that Time.before() returns false when earlier date is compared
     * to itself
     */
    @Test
    public void test22() {
        Time t = Time.valueOf("08:30:59");
        Time t2 = new Time(t.getTime());
        assertFalse(t.before(t2), "Error t.after(t2) = true");
        assertFalse(t2.before(t), "Error t2.after(t) = true");
    }

    /*
     * Validate that Time.compareTo returns 0 when both Date objects are the
     * same
     */
    @Test
    public void test23() {
        Time t = Time.valueOf("08:30:59");
        assertTrue(t.compareTo(t) == 0, "Error t.compareTo(t) !=0");
    }

    /*
     * Validate thatTime.compareTo returns 0 when both Time objects are the same
     */
    @Test
    public void test24() {
        Time t = Time.valueOf("08:30:59");
        Time t2 = new Time(t.getTime());
        assertTrue(t.compareTo(t2) == 0, "Error t.compareTo(t2) !=0");
    }

    /*
     * Validate that Time.compareTo returns 1 when comparing a later Time to an
     * earlier Time
     */
    @Test
    public void test25() {
        Time t = Time.valueOf("08:30:59");
        Time t2 = new Time(t.getTime() + 1);
        assertTrue(t2.compareTo(t) == 1, "Error t2.compareTo(t) !=1");
    }

    /*
     * Validate thatTime.compareTo returns 1 when comparing a later Time to an
     * earlier Time
     */
    @Test
    public void test26() {
        Time t = Time.valueOf("08:30:59");
        Time t2 = new Time(t.getTime() + 1);
        assertTrue(t.compareTo(t2) == -1, "Error t.compareTo(t2) != -1");
    }

    /*
     * DataProvider used to provide Time values which are not valid and are used
     * to validate that an IllegalArgumentException will be thrown from the
     * valueOf method
     */
    @DataProvider(name = "invalidTimeValues")
    private Object[][] invalidTimeValues() {
        return new Object[][]{
            {"2009-11-01 10:50:01"},
            {"1961-08-30 10:50:01.1"},
            {"1961-08-30"},
            {"00:00:00."},
            {"10:50:0.1"},
            {":00:00"},
            {"00::00"},
            {"00:00:"},
            {"::"},
            {" : : "},
            {"0a:00:00"},
            {"00:bb:00"},
            {"00:01:cc"},
            {"08:10:Batman"},
            {"08:10:10:10"},
            {"08:10"},
            {"a:b:c"},
            {null},
            {"8:"}
        };
    }

    /*
     * DataProvider used to provide Time values which are  valid and are used
     * to validate that an IllegalArgumentException will  not be thrown from the
     * valueOf method.  It also contains the expected return value from
     * toString()
     */
    @DataProvider(name = "validTimeValues")
    private Object[][] validTimeValues() {
        return new Object[][]{
            {"10:50:01", "10:50:01"},
            {"01:1:1", "01:01:01"},
            {"01:01:1", "01:01:01"},
            {"1:01:1", "01:01:01"},
            {"2:02:02", "02:02:02"},
            {"2:02:2", "02:02:02"},
            {"10:50:1", "10:50:01"},
            {"00:00:00", "00:00:00"},
            {"08:30:59", "08:30:59"},
            {"9:0:1", "09:00:01"}
        };
    }
}

quality85%

¤ Dauer der Verarbeitung: 0.1 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.