X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;ds=sidebyside;f=test%2Fdcp_time_test.cc;h=504e9fd1b1689557bfbcb50095f4a0952112217a;hb=4d6c8aaf0167cde3bb63e9014604243bdc47b1a1;hp=9f0072ab18f289f36b8fd40d30f6292fde18d24e;hpb=3c5c59b5244d8948f05a3251ec14cb20fbcc0d7c;p=libdcp.git diff --git a/test/dcp_time_test.cc b/test/dcp_time_test.cc index 9f0072ab..504e9fd1 100644 --- a/test/dcp_time_test.cc +++ b/test/dcp_time_test.cc @@ -1,75 +1,168 @@ /* - Copyright (C) 2013 Carl Hetherington + Copyright (C) 2013-2019 Carl Hetherington - This program is free software; you can redistribute it and/or modify + This file is part of libdcp. + + libdcp is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. - This program is distributed in the hope that it will be useful, + libdcp 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 for more details. You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + along with libdcp. If not, see . + + In addition, as a special exception, the copyright holders give + permission to link the code of portions of this program with the + OpenSSL library under certain conditions as described in each + individual source file, and distribute linked combinations + including the two. + You must obey the GNU General Public License in all respects + for all of the code used other than OpenSSL. If you modify + file(s) with this exception, you may extend this exception to your + version of the file(s), but you are not obligated to do so. If you + do not wish to do so, delete this exception statement from your + version. If you delete this exception statement from all source + files in the program, then also delete it here. */ #include #include "dcp_time.h" +#include "exceptions.h" + +using boost::optional; /** Check that dcp::Time works */ BOOST_AUTO_TEST_CASE (dcp_time) { - dcp::Time t (977143, 24); + /* tcr of 250 makes the editable event length the same as an Interop `tick' */ + dcp::Time t (977143, 24, 250); - BOOST_CHECK_EQUAL (t.t, 73); + BOOST_CHECK_EQUAL (t.e, 73); BOOST_CHECK_EQUAL (t.s, 34); BOOST_CHECK_EQUAL (t.m, 18); BOOST_CHECK_EQUAL (t.h, 11); - BOOST_CHECK_EQUAL (t.to_string(), "11:18:34:73"); - BOOST_CHECK_EQUAL (t.to_ticks(), 10178573); + BOOST_CHECK_EQUAL (t.as_string(dcp::INTEROP), "11:18:34:073"); - dcp::Time a (3, 2, 3, 4); - dcp::Time b (2, 3, 4, 5); + /* Use a tcr of 24 so that the editable event is a frame */ + dcp::Time a (3, 2, 3, 4, 24); + dcp::Time b (2, 3, 4, 5, 24); dcp::Time r = a - b; BOOST_CHECK_EQUAL (r.h, 0); BOOST_CHECK_EQUAL (r.m, 58); BOOST_CHECK_EQUAL (r.s, 58); - BOOST_CHECK_EQUAL (r.t, 249); - BOOST_CHECK_EQUAL (r.to_string(), "0:58:58:249"); - BOOST_CHECK_EQUAL (r.to_ticks(), 884749); + BOOST_CHECK_EQUAL (r.e, 23); + BOOST_CHECK_EQUAL (r.as_string(dcp::INTEROP), "00:58:58:023"); - a = dcp::Time (1, 58, 56, 240); - b = dcp::Time (1, 7, 12, 120); + /* Different tcr (25) */ + a = dcp::Time (1, 58, 56, 2, 25); + b = dcp::Time (1, 7, 12, 1, 25); r = a + b; BOOST_CHECK_EQUAL (r.h, 3); BOOST_CHECK_EQUAL (r.m, 6); - BOOST_CHECK_EQUAL (r.s, 9); - BOOST_CHECK_EQUAL (r.t, 110); - BOOST_CHECK_EQUAL (r.to_string(), "3:6:9:110"); - BOOST_CHECK_EQUAL (r.to_ticks(), 2792360); + BOOST_CHECK_EQUAL (r.s, 8); + BOOST_CHECK_EQUAL (r.e, 3); + BOOST_CHECK_EQUAL (r.as_string(dcp::INTEROP), "03:06:08:003"); + BOOST_CHECK_EQUAL (r.as_string(dcp::SMPTE), "03:06:08:03"); - a = dcp::Time (24, 12, 6, 3); - b = dcp::Time (16, 8, 4, 2); + /* Another arbitrary tcr (30) */ + a = dcp::Time (24, 12, 6, 3, 30); + b = dcp::Time (16, 8, 4, 2, 30); BOOST_CHECK_CLOSE (a / b, 1.5, 1e-5); - BOOST_CHECK_EQUAL (dcp::Time (4128391203LL).to_ticks(), 4128391203LL); - BOOST_CHECK_EQUAL (dcp::Time (60000).to_ticks(), 60000); + a = dcp::Time (3600 * 24, 24, 250); + BOOST_CHECK_EQUAL (a.h, 1); + BOOST_CHECK_EQUAL (a.m, 0); + BOOST_CHECK_EQUAL (a.s, 0); + BOOST_CHECK_EQUAL (a.e, 0); + + a = dcp::Time (60 * 24, 24, 250); + BOOST_CHECK_EQUAL (a.h, 0); + BOOST_CHECK_EQUAL (a.m, 1); + BOOST_CHECK_EQUAL (a.s, 0); + BOOST_CHECK_EQUAL (a.e, 0); /* Check rounding; 3424 is 142.666666666... seconds or 0.166666666... ticks */ - a = dcp::Time (3424, 24); + a = dcp::Time (3424, 24, 250); BOOST_CHECK_EQUAL (a.h, 0); BOOST_CHECK_EQUAL (a.m, 2); BOOST_CHECK_EQUAL (a.s, 22); - BOOST_CHECK_EQUAL (a.t, 167); + BOOST_CHECK_EQUAL (a.e, 167); - a = dcp::Time (3425, 24); + a = dcp::Time (3425, 24, 250); BOOST_CHECK_EQUAL (a.h, 0); BOOST_CHECK_EQUAL (a.m, 2); BOOST_CHECK_EQUAL (a.s, 22); - BOOST_CHECK_EQUAL (a.t, 177); + BOOST_CHECK_EQUAL (a.e, 177); + + /* Check addition of times with different tcrs */ + a = dcp::Time (0, 0, 0, 3, 24); + b = dcp::Time (0, 0, 0, 4, 48); + r = a + b; + BOOST_CHECK_EQUAL (r, dcp::Time (0, 0, 0, 240, 1152)); + + /* Check rounding on conversion from seconds */ + BOOST_CHECK_EQUAL (dcp::Time (80.990, 1000), dcp::Time (0, 1, 20, 990, 1000)); + + /* Check rebase */ + a = dcp::Time (1, 58, 56, 2, 25); + BOOST_CHECK_EQUAL (a.rebase(250), dcp::Time(1, 58, 56, 20, 250)); + b = dcp::Time (9, 12, 41, 17, 99); + BOOST_CHECK_EQUAL (b.rebase(250), dcp::Time(9, 12, 41, 43, 250)); + a = dcp::Time (0, 2, 57, 999, 1000); + BOOST_CHECK_EQUAL (a.rebase(250), dcp::Time(0, 2, 58, 0, 250)); + a = dcp::Time (0, 47, 9, 998, 1000); + BOOST_CHECK_EQUAL (a.rebase(250), dcp::Time(0, 47, 10, 0, 250)); + + /* Check some allowed constructions from string */ + + /* Interop type 1 */ + a = dcp::Time ("01:23:45:123", optional()); + BOOST_CHECK_EQUAL (a, dcp::Time (1, 23, 45, 123, 250)); + /* Interop type 2 */ + a = dcp::Time ("01:23:45.123", optional()); + BOOST_CHECK_EQUAL (a, dcp::Time (1, 23, 45, 123, 1000)); + /* SMPTE */ + a = dcp::Time ("01:23:45:12", 250); + BOOST_CHECK_EQUAL (a, dcp::Time (1, 23, 45, 12, 250)); + + /* Check some disallowed constructions from string */ + BOOST_CHECK_THROW (dcp::Time ("01:23:45:1234", optional()), dcp::ReadError); + BOOST_CHECK_THROW (dcp::Time ("01:23:45:1234:66", optional()), dcp::ReadError); + BOOST_CHECK_THROW (dcp::Time ("01:23:45:", optional()), dcp::ReadError); + BOOST_CHECK_THROW (dcp::Time ("01:23::123", optional()), dcp::ReadError); + BOOST_CHECK_THROW (dcp::Time ("01::45:123", optional()), dcp::ReadError); + BOOST_CHECK_THROW (dcp::Time (":23:45:123", optional()), dcp::ReadError); + BOOST_CHECK_THROW (dcp::Time ("01:23:45.1234", optional()), dcp::ReadError); + BOOST_CHECK_THROW (dcp::Time ("01:23:45.1234.66", optional()), dcp::ReadError); + BOOST_CHECK_THROW (dcp::Time ("01:23:45.", optional()), dcp::ReadError); + BOOST_CHECK_THROW (dcp::Time ("01:23:.123", optional()), dcp::ReadError); + BOOST_CHECK_THROW (dcp::Time ("01::45.123", optional()), dcp::ReadError); + BOOST_CHECK_THROW (dcp::Time (":23:45.123", optional()), dcp::ReadError); + BOOST_CHECK_THROW (dcp::Time ("01:23:45:123", 250), dcp::ReadError); + BOOST_CHECK_THROW (dcp::Time ("01:23:45:123:66", 250), dcp::ReadError); + BOOST_CHECK_THROW (dcp::Time ("01:23:45:", 250), dcp::ReadError); + BOOST_CHECK_THROW (dcp::Time ("01:23::123", 250), dcp::ReadError); + BOOST_CHECK_THROW (dcp::Time ("01::45:123", 250), dcp::ReadError); + BOOST_CHECK_THROW (dcp::Time (":23:45:123", 250), dcp::ReadError); + + /* Check operator< and operator> */ + BOOST_CHECK (dcp::Time (3, 2, 3, 4, 24) < dcp::Time (3, 2, 3, 5, 24)); + BOOST_CHECK (!(dcp::Time (3, 2, 3, 4, 24) < dcp::Time (3, 2, 3, 4, 24))); + BOOST_CHECK (dcp::Time (3, 2, 3, 5, 24) > dcp::Time (3, 2, 3, 4, 24)); + BOOST_CHECK (!(dcp::Time (3, 2, 3, 4, 24) > dcp::Time (3, 2, 3, 4, 24))); + BOOST_CHECK (dcp::Time (6, 0, 0, 0, 24) < dcp::Time (7, 0, 0, 0, 24)); + BOOST_CHECK (dcp::Time (0, 6, 0, 0, 24) < dcp::Time (0, 7, 0, 0, 24)); + BOOST_CHECK (dcp::Time (0, 0, 6, 0, 24) < dcp::Time (0, 0, 7, 0, 24)); + BOOST_CHECK (dcp::Time (0, 0, 0, 6, 24) < dcp::Time (0, 0, 0, 7, 24)); + BOOST_CHECK (dcp::Time (7, 0, 0, 0, 24) > dcp::Time (6, 0, 0, 0, 24)); + BOOST_CHECK (dcp::Time (0, 7, 0, 0, 24) > dcp::Time (0, 6, 0, 0, 24)); + BOOST_CHECK (dcp::Time (0, 0, 7, 0, 24) > dcp::Time (0, 0, 6, 0, 24)); + BOOST_CHECK (dcp::Time (0, 0, 0, 7, 24) > dcp::Time (0, 0, 0, 6, 24)); }