diff --git a/data/test_dates4display.m b/data/test_dates4display.m
new file mode 100644
index 0000000000000000000000000000000000000000..b84264f55ab1f24992b7cef7edc4978321200b49
--- /dev/null
+++ b/data/test_dates4display.m
@@ -0,0 +1,4 @@
+expected_str_1 = sprintf('toto is an empty dates object.\n');
+expected_str_2 = sprintf('toto = <dates: 1950Q1, 1950Q2>\n');
+expected_str_3 = sprintf('toto = <dates: 1950Q1, 1950Q2, ..., 1950Q4, 1951Q1>\n');
+expected_str_4 = sprintf('toto = <dates: 1950Q1, 1950Q2, 1950Q3, 1950Q4, 1951Q1>\n');
diff --git a/src/@dates/copy.m b/src/@dates/copy.m
index e15a508871a5418e3e7dd3bc345926e36f64f9ac..ddb4c9a145fb1d2d7ba0d6e99820037d84aa1b5d 100644
--- a/src/@dates/copy.m
+++ b/src/@dates/copy.m
@@ -1,4 +1,4 @@
-function p = copy(o)
+function p = copy(o) % --*-- Unitary tests --*--
 
 % Do a copy of a dates object.
 %
@@ -26,3 +26,24 @@ function p = copy(o)
 p = dates();
 p.freq = o.freq;
 p.time = o.time;
+
+%@test:1
+%$ % Define a dates object
+%$ o = dates('1945Q3','1944Q4');
+%$ q = dates('1945Q3','1944Q4');
+%$
+%$ % Call the tested routine.
+%$ try
+%$     p = copy(o);
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$ 
+%$ if t(1)
+%$      o.sort_();
+%$      t(2) = dassert(p, q);
+%$ end
+%$
+%$ T = all(t);
+%@eof:1
\ No newline at end of file
diff --git a/src/@dates/dates.m b/src/@dates/dates.m
index 71aebea2c5e854118fbb8772a3941a42252fc851..8c837f8ed7025d3df4e5ece2f9cbc5b6212c80e2 100644
--- a/src/@dates/dates.m
+++ b/src/@dates/dates.m
@@ -109,6 +109,21 @@ classdef dates<handle % --*-- Unitary tests --*--
             end
             error('dates:ArgCheck','You should first read the manual!')
         end % dates constructor.
+        % Other methods
+        p = sort(o);
+        o = sort_(o);
+        p = unique(o);
+        o = unique_(o);
+        p = append(o, d);
+        o = append_(o, d);
+        p = pop(o, d);
+        o = pop_(o, d);
+        p = remove(o, d);
+        o = remove_(o, d);
+        s = char(o);
+        a = double(o);
+        n = ndat(o);
+        n = length(o);
     end % methods 
 end % classdef
 
diff --git a/src/@dates/end.m b/src/@dates/end.m
index 5de7f0b9cbfbca80eb342e9935f28a3924c86dfc..1f0d6212fcd89a2cd4f2147c7e044e93081799cd 100644
--- a/src/@dates/end.m
+++ b/src/@dates/end.m
@@ -1,4 +1,4 @@
-function lastIndex = end(o, k, n)
+function lastIndex = end(o, k, n) % --*-- Unitary tests --*--
 
 % Overloads end keyword.
 %
@@ -27,3 +27,23 @@ function lastIndex = end(o, k, n)
 
 assert(k==1 && n==1, 'dates:end:ArgCheck', 'dates only has one dimension');
 lastIndex = o.ndat();
+
+%@test:1
+%$ % Define a dates object
+%$ o = dates('1938Q4'):dates('2015Q4');
+%$ q = dates('2015Q4');
+%$
+%$ % Call the tested routine.
+%$ try
+%$     p = o(end);
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$ 
+%$ if t(1)
+%$      t(2) = dassert(p, q);
+%$ end
+%$
+%$ T = all(t);
+%@eof:1
\ No newline at end of file
diff --git a/src/@dates/isequal.m b/src/@dates/isequal.m
index 62f9e10af1f1929d0a93ee6af4c2fd544f1a11a3..db945c77e862430611aa3ad101d86bf2bcdab272 100644
--- a/src/@dates/isequal.m
+++ b/src/@dates/isequal.m
@@ -1,4 +1,4 @@
-function l = isequal(o, p, fake)
+function l = isequal(o, p, fake) % --*-- Unitary tests --*--
 
 % Overloads isequal function for dates objects. Returns true (1) iff o and p have the same elements.
 %
diff --git a/src/@dates/length.m b/src/@dates/length.m
index 6ee6ae8c31b2fae243604151fb227c2d145c5d9c..c4897196296f2e8f0a9d6f3c3b45c7f03f1f6cb5 100644
--- a/src/@dates/length.m
+++ b/src/@dates/length.m
@@ -1,4 +1,4 @@
-function n = length(o)
+function n = length(o) % --*-- Unitary tests --*--
 
 % Returns the number of elements in a dates object.
 %
diff --git a/src/@dates/private/comparison_arg_checks.m b/src/@dates/private/comparison_arg_checks.m
index 4983fe8da1abd46c1ffe60c45f66e49038afc9d6..82fa4556236a8d57b6435d8c282729726b3ae959 100644
--- a/src/@dates/private/comparison_arg_checks.m
+++ b/src/@dates/private/comparison_arg_checks.m
@@ -1,4 +1,4 @@
-function [o, p] = comparison_arg_checks(varargin)
+function [o, p] = comparison_arg_checks(varargin) % --*-- Unitary tests --*--
 
 % Returns two dates objects or an error if objects to be compared are not compatible.
 %
@@ -45,4 +45,121 @@ if ~isequal(varargin{1}.ndat, varargin{2}.ndat) && ~(isequal(varargin{1}.ndat,1)
 end
 
 o = varargin{1};
-p = varargin{2};
\ No newline at end of file
+p = varargin{2};
+
+%@test:1
+%$ OPATH = pwd();
+%$ [DATES_PATH, junk1, junk2] = fileparts(which('dates'));
+%$ cd([DATES_PATH '/private']);
+%$
+%$ try
+%$     [o, p] = comparison_arg_checks(1);
+%$     t(1) = false;
+%$ catch
+%$     t(1) = true;
+%$ end
+%$
+%$ T = all(t);
+%$ cd(OPATH);
+%@eof:1
+
+%@test:2
+%$ OPATH = pwd();
+%$ [DATES_PATH, junk1, junk2] = fileparts(which('dates'));
+%$ cd([DATES_PATH '/private']);
+%$
+%$ try
+%$     [o, p] = comparison_arg_checks('make', 'my', 'day');
+%$     t(1) = false;
+%$ catch
+%$     t(1) = true;
+%$ end
+%$
+%$ T = all(t);
+%$ cd(OPATH);
+%@eof:2
+
+%@test:3
+%$ OPATH = pwd();
+%$ [DATES_PATH, junk1, junk2] = fileparts(which('dates'));
+%$ cd([DATES_PATH '/private']);
+%$
+%$ try
+%$     [o, p] = comparison_arg_checks('punk', dates('1950Q1'));
+%$     t(1) = false;
+%$ catch
+%$     t(1) = true;
+%$ end
+%$
+%$ T = all(t);
+%$ cd(OPATH);
+%@eof:3
+
+%@test:4
+%$ OPATH = pwd();
+%$ [DATES_PATH, junk1, junk2] = fileparts(which('dates'));
+%$ cd([DATES_PATH '/private']);
+%$
+%$ try
+%$     [o, p] = comparison_arg_checks(dates('1950Q1'), 1);
+%$     t(1) = false;
+%$ catch
+%$     t(1) = true;
+%$ end
+%$
+%$ T = all(t);
+%$ cd(OPATH);
+%@eof:4
+
+%@test:5
+%$ OPATH = pwd();
+%$ [DATES_PATH, junk1, junk2] = fileparts(which('dates'));
+%$ cd([DATES_PATH '/private']);
+%$
+%$ try
+%$     [o, p] = comparison_arg_checks(dates('1950Q1'), dates('1950M1'));
+%$     t(1) = false;
+%$ catch
+%$     t(1) = true;
+%$ end
+%$
+%$ T = all(t);
+%$ cd(OPATH);
+%@eof:5
+
+%@test:6
+%$ OPATH = pwd();
+%$ [DATES_PATH, junk1, junk2] = fileparts(which('dates'));
+%$ cd([DATES_PATH '/private']);
+%$
+%$ try
+%$     [o, p] = comparison_arg_checks(dates('1950Q1'):dates('1950Q2'), dates('1950Q1'):dates('1950Q3'));
+%$     t(1) = false;
+%$ catch
+%$     t(1) = true;
+%$ end
+%$
+%$ T = all(t);
+%$ cd(OPATH);
+%@eof:6
+
+%@test:7
+%$ OPATH = pwd();
+%$ [DATES_PATH, junk1, junk2] = fileparts(which('dates'));
+%$ cd([DATES_PATH '/private']);
+%$
+%$ try
+%$     [o, p] = comparison_arg_checks(dates('1950Q2'), dates('1950Q1'));
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$
+%$ if t(1)
+%$     t(2) = dassert(o, dates('1950Q2'));
+%$     t(3) = dassert(p, dates('1950Q1'));
+%$ end
+%$
+%$ T = all(t);
+%$ cd(OPATH);
+%@eof:7
\ No newline at end of file
diff --git a/src/@dates/private/dates4display.m b/src/@dates/private/dates4display.m
index 7dc6109e2b9d7d9f326ccdfb0be21ebff59dfd6e..b8d1a0a49989017a28bb66aa342d005007fc6d98 100644
--- a/src/@dates/private/dates4display.m
+++ b/src/@dates/private/dates4display.m
@@ -1,4 +1,4 @@
-function str = dates4display(o, name, max_number_of_elements)
+function str = dates4display(o, name, max_number_of_elements) % --*-- Unitary tests --*--
 
 % Converts a list object to a string.
 %
@@ -45,4 +45,117 @@ else
     str = sprintf('%s%s, ', str, '...');
     str = sprintf('%s%s, ', str, date2string(o.time(o.length()-1,:),o.freq));
 end
-str = sprintf('%s%s>', str, date2string(o.time(o.length(),:),o.freq));
\ No newline at end of file
+str = sprintf('%s%s>\n', str, date2string(o.time(o.length(),:),o.freq));
+
+%@test:1
+%$ OPATH = pwd();
+%$ [DATES_PATH, junk1, junk2] = fileparts(which('dates'));
+%$ cd([DATES_PATH '/private']);
+%$ addpath('../../../data/')
+%$
+%$ try
+%$     toto = dates();
+%$     str = dates4display(toto, 'toto', 5);
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$
+%$ if t(1)
+%$     test_dates4display;
+%$     try
+%$         t(2) = dassert(str, expected_str_1);
+%$     catch
+%$         t(2) = false;
+%$     end
+%$ end
+%$
+%$ T = all(t);
+%$ rmpath('../../../data/')
+%$ cd(OPATH);
+%@eof:1
+
+%@test:2
+%$ OPATH = pwd();
+%$ [DATES_PATH, junk1, junk2] = fileparts(which('dates'));
+%$ cd([DATES_PATH '/private']);
+%$ addpath('../../../data/')
+%$
+%$ try
+%$     toto = dates('1950Q1'):dates('1950Q2');
+%$     str = dates4display(toto, 'toto', 5);
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$
+%$ if t(1)
+%$     test_dates4display;
+%$     try
+%$         t(2) = dassert(str, expected_str_2);
+%$     catch
+%$         t(2) = false;
+%$     end
+%$ end
+%$
+%$ T = all(t);
+%$ rmpath('../../../data/')
+%$ cd(OPATH);
+%@eof:2
+
+%@test:3
+%$ OPATH = pwd();
+%$ [DATES_PATH, junk1, junk2] = fileparts(which('dates'));
+%$ cd([DATES_PATH '/private']);
+%$ addpath('../../../data/')
+%$
+%$ try
+%$     toto = dates('1950Q1'):dates('1951Q1');
+%$     str = dates4display(toto, 'toto', 4);
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$
+%$ if t(1)
+%$     test_dates4display;
+%$     try
+%$         t(2) = dassert(str, expected_str_3);
+%$     catch
+%$         t(2) = false;
+%$     end
+%$ end
+%$
+%$ T = all(t);
+%$ rmpath('../../../data/')
+%$ cd(OPATH);
+%@eof:3
+
+%@test:4
+%$ OPATH = pwd();
+%$ [DATES_PATH, junk1, junk2] = fileparts(which('dates'));
+%$ cd([DATES_PATH '/private']);
+%$ addpath('../../../data/')
+%$
+%$ try
+%$     toto = dates('1950Q1'):dates('1951Q1');
+%$     str = dates4display(toto, 'toto', 6);
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$
+%$ if t(1)
+%$     test_dates4display;
+%$     try
+%$         t(2) = dassert(str, expected_str_4);
+%$     catch
+%$         t(2) = false;
+%$     end
+%$ end
+%$
+%$ T = all(t);
+%$ rmpath('../../../data/')
+%$ cd(OPATH);
+%@eof:4
+
diff --git a/src/@dates/private/greaterorequal.m b/src/@dates/private/greaterorequal.m
index 00d35982b1822115a7d7dc8439ad993017721bd4..d99a0ce42a4dd15a6886ff5e4a6fb2bffb605fa5 100644
--- a/src/@dates/private/greaterorequal.m
+++ b/src/@dates/private/greaterorequal.m
@@ -1,6 +1,6 @@
-function c = greaterorequal(a,b)
+function c = greaterorequal(a,b) % --*-- Unitary tests --*--
 
-% Copyright (C) 2013-2014 Dynare Team
+% Copyright (C) 2013-2015 Dynare Team
 %
 % This code is free software: you can redistribute it and/or modify
 % it under the terms of the GNU General Public License as published by
@@ -27,4 +27,123 @@ else
             c = false;
         end
     end
-end
\ No newline at end of file
+end
+
+%@test:1
+%$ OPATH = pwd();
+%$ [DATES_PATH, junk1, junk2] = fileparts(which('dates'));
+%$ cd([DATES_PATH '/private']);
+%$
+%$ a = [2, 4];
+%$ b = [1, 2];
+%$
+%$ try
+%$     boolean = greaterorequal(a, b);
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$
+%$ if t(1)
+%$     t(2) = dassert(boolean, true);
+%$ end
+%$
+%$ T = all(t);
+%$ cd(OPATH);
+%@eof:1
+
+%@test:2
+%$ OPATH = pwd();
+%$ [DATES_PATH, junk1, junk2] = fileparts(which('dates'));
+%$ cd([DATES_PATH '/private']);
+%$
+%$ a = [1, 4];
+%$ b = [2, 2];
+%$
+%$ try
+%$     boolean = greaterorequal(a, b);
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$
+%$ if t(1)
+%$     t(2) = dassert(boolean, false);
+%$ end
+%$
+%$ T = all(t);
+%$ cd(OPATH);
+%@eof:2
+
+%@test:3
+%$ OPATH = pwd();
+%$ [DATES_PATH, junk1, junk2] = fileparts(which('dates'));
+%$ cd([DATES_PATH '/private']);
+%$
+%$ a = [1, 4];
+%$ b = [1, 2];
+%$
+%$ try
+%$     boolean = greaterorequal(a, b);
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$
+%$ if t(1)
+%$     t(2) = dassert(boolean, true);
+%$ end
+%$
+%$ T = all(t);
+%$ cd(OPATH);
+%@eof:3
+
+%@test:4
+%$ OPATH = pwd();
+%$ [DATES_PATH, junk1, junk2] = fileparts(which('dates'));
+%$ cd([DATES_PATH '/private']);
+%$
+%$ a = [1, 2];
+%$ b = [1, 4];
+%$
+%$ try
+%$     boolean = greaterorequal(a, b);
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$
+%$ if t(1)
+%$     t(2) = dassert(boolean, false);
+%$ end
+%$
+%$ T = all(t);
+%$ cd(OPATH);
+%@eof:4
+
+%@test:5
+%$ OPATH = pwd();
+%$ [DATES_PATH, junk1, junk2] = fileparts(which('dates'));
+%$ cd([DATES_PATH '/private']);
+%$
+%$ a = [1, 2];
+%$ b = [1, 2];
+%$
+%$ try
+%$     boolean = greaterorequal(a, b);
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$
+%$ if t(1)
+%$     t(2) = dassert(boolean, true);
+%$ end
+%$
+%$ T = all(t);
+%$ cd(OPATH);
+%@eof:5
+
+
+
+
diff --git a/src/@dates/private/greaterthan.m b/src/@dates/private/greaterthan.m
index ae0b4173ec7776d7bd72159c742ac5c99b501a9e..ffc7695d63b4a86d8e85492e1050cc79bf90416e 100644
--- a/src/@dates/private/greaterthan.m
+++ b/src/@dates/private/greaterthan.m
@@ -1,4 +1,4 @@
-function c = greaterthan(a,b)
+function c = greaterthan(a,b) % --*-- Unitary tests --*--
 
 % Copyright (C) 2013-2014 Dynare Team
 %
@@ -27,4 +27,119 @@ else
             c = false;
         end
     end
-end
\ No newline at end of file
+end
+
+%@test:1
+%$ OPATH = pwd();
+%$ [DATES_PATH, junk1, junk2] = fileparts(which('dates'));
+%$ cd([DATES_PATH '/private']);
+%$
+%$ a = [2, 4];
+%$ b = [1, 2];
+%$
+%$ try
+%$     boolean = greaterthan(a, b);
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$
+%$ if t(1)
+%$     t(2) = dassert(boolean, true);
+%$ end
+%$
+%$ T = all(t);
+%$ cd(OPATH);
+%@eof:1
+
+%@test:2
+%$ OPATH = pwd();
+%$ [DATES_PATH, junk1, junk2] = fileparts(which('dates'));
+%$ cd([DATES_PATH '/private']);
+%$
+%$ a = [1, 4];
+%$ b = [2, 2];
+%$
+%$ try
+%$     boolean = greaterthan(a, b);
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$
+%$ if t(1)
+%$     t(2) = dassert(boolean, false);
+%$ end
+%$
+%$ T = all(t);
+%$ cd(OPATH);
+%@eof:2
+
+%@test:3
+%$ OPATH = pwd();
+%$ [DATES_PATH, junk1, junk2] = fileparts(which('dates'));
+%$ cd([DATES_PATH '/private']);
+%$
+%$ a = [1, 4];
+%$ b = [1, 2];
+%$
+%$ try
+%$     boolean = greaterthan(a, b);
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$
+%$ if t(1)
+%$     t(2) = dassert(boolean, true);
+%$ end
+%$
+%$ T = all(t);
+%$ cd(OPATH);
+%@eof:3
+
+%@test:4
+%$ OPATH = pwd();
+%$ [DATES_PATH, junk1, junk2] = fileparts(which('dates'));
+%$ cd([DATES_PATH '/private']);
+%$
+%$ a = [1, 2];
+%$ b = [1, 4];
+%$
+%$ try
+%$     boolean = greaterthan(a, b);
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$
+%$ if t(1)
+%$     t(2) = dassert(boolean, false);
+%$ end
+%$
+%$ T = all(t);
+%$ cd(OPATH);
+%@eof:4
+
+%@test:5
+%$ OPATH = pwd();
+%$ [DATES_PATH, junk1, junk2] = fileparts(which('dates'));
+%$ cd([DATES_PATH '/private']);
+%$
+%$ a = [1, 2];
+%$ b = [1, 2];
+%$
+%$ try
+%$     boolean = greaterthan(a, b);
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$
+%$ if t(1)
+%$     t(2) = dassert(boolean, false);
+%$ end
+%$
+%$ T = all(t);
+%$ cd(OPATH);
+%@eof:5
diff --git a/src/@dates/private/lessorequal.m b/src/@dates/private/lessorequal.m
index 7f85bb95ad15ef65151a1d69e444f9f4722c8aab..58d05e7a3598b29a3ce218858fee311a558a508b 100644
--- a/src/@dates/private/lessorequal.m
+++ b/src/@dates/private/lessorequal.m
@@ -1,4 +1,4 @@
-function c = lessorequal(a, b)
+function c = lessorequal(a, b) % --*-- Unitary tests --*--
 
 % Copyright (C) 2013-2014 Dynare Team
 %
@@ -27,4 +27,119 @@ else
             c = false;
         end
     end
-end
\ No newline at end of file
+end
+
+%@test:1
+%$ OPATH = pwd();
+%$ [DATES_PATH, junk1, junk2] = fileparts(which('dates'));
+%$ cd([DATES_PATH '/private']);
+%$
+%$ a = [2, 4];
+%$ b = [1, 2];
+%$
+%$ try
+%$     boolean = lessorequal(a, b);
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$
+%$ if t(1)
+%$     t(2) = dassert(boolean, false);
+%$ end
+%$
+%$ T = all(t);
+%$ cd(OPATH);
+%@eof:1
+
+%@test:2
+%$ OPATH = pwd();
+%$ [DATES_PATH, junk1, junk2] = fileparts(which('dates'));
+%$ cd([DATES_PATH '/private']);
+%$
+%$ a = [1, 4];
+%$ b = [2, 2];
+%$
+%$ try
+%$     boolean = lessorequal(a, b);
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$
+%$ if t(1)
+%$     t(2) = dassert(boolean, true);
+%$ end
+%$
+%$ T = all(t);
+%$ cd(OPATH);
+%@eof:2
+
+%@test:3
+%$ OPATH = pwd();
+%$ [DATES_PATH, junk1, junk2] = fileparts(which('dates'));
+%$ cd([DATES_PATH '/private']);
+%$
+%$ a = [1, 4];
+%$ b = [1, 2];
+%$
+%$ try
+%$     boolean = lessorequal(a, b);
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$
+%$ if t(1)
+%$     t(2) = dassert(boolean, false);
+%$ end
+%$
+%$ T = all(t);
+%$ cd(OPATH);
+%@eof:3
+
+%@test:4
+%$ OPATH = pwd();
+%$ [DATES_PATH, junk1, junk2] = fileparts(which('dates'));
+%$ cd([DATES_PATH '/private']);
+%$
+%$ a = [1, 2];
+%$ b = [1, 4];
+%$
+%$ try
+%$     boolean = lessorequal(a, b);
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$
+%$ if t(1)
+%$     t(2) = dassert(boolean, true);
+%$ end
+%$
+%$ T = all(t);
+%$ cd(OPATH);
+%@eof:4
+
+%@test:5
+%$ OPATH = pwd();
+%$ [DATES_PATH, junk1, junk2] = fileparts(which('dates'));
+%$ cd([DATES_PATH '/private']);
+%$
+%$ a = [1, 2];
+%$ b = [1, 2];
+%$
+%$ try
+%$     boolean = lessorequal(a, b);
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$
+%$ if t(1)
+%$     t(2) = dassert(boolean, true);
+%$ end
+%$
+%$ T = all(t);
+%$ cd(OPATH);
+%@eof:5
diff --git a/src/@dates/private/lessthan.m b/src/@dates/private/lessthan.m
index 549199efc718c9c4b8d416da35d9cd5efca11bab..c2e32281bb2e4bf6f3027abf50d6bdd1619b9bef 100644
--- a/src/@dates/private/lessthan.m
+++ b/src/@dates/private/lessthan.m
@@ -1,4 +1,4 @@
-function c = lessthan(a,b)
+function c = lessthan(a,b) % --*-- Unitary tests --*--
 
 % Copyright (C) 2013-2014 Dynare Team
 %
@@ -28,3 +28,118 @@ else
         end
     end
 end
+
+%@test:1
+%$ OPATH = pwd();
+%$ [DATES_PATH, junk1, junk2] = fileparts(which('dates'));
+%$ cd([DATES_PATH '/private']);
+%$
+%$ a = [2, 4];
+%$ b = [1, 2];
+%$
+%$ try
+%$     boolean = lessthan(a, b);
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$
+%$ if t(1)
+%$     t(2) = dassert(boolean, false);
+%$ end
+%$
+%$ T = all(t);
+%$ cd(OPATH);
+%@eof:1
+
+%@test:2
+%$ OPATH = pwd();
+%$ [DATES_PATH, junk1, junk2] = fileparts(which('dates'));
+%$ cd([DATES_PATH '/private']);
+%$
+%$ a = [1, 4];
+%$ b = [2, 2];
+%$
+%$ try
+%$     boolean = lessthan(a, b);
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$
+%$ if t(1)
+%$     t(2) = dassert(boolean, true);
+%$ end
+%$
+%$ T = all(t);
+%$ cd(OPATH);
+%@eof:2
+
+%@test:3
+%$ OPATH = pwd();
+%$ [DATES_PATH, junk1, junk2] = fileparts(which('dates'));
+%$ cd([DATES_PATH '/private']);
+%$
+%$ a = [1, 4];
+%$ b = [1, 2];
+%$
+%$ try
+%$     boolean = lessthan(a, b);
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$
+%$ if t(1)
+%$     t(2) = dassert(boolean, false);
+%$ end
+%$
+%$ T = all(t);
+%$ cd(OPATH);
+%@eof:3
+
+%@test:4
+%$ OPATH = pwd();
+%$ [DATES_PATH, junk1, junk2] = fileparts(which('dates'));
+%$ cd([DATES_PATH '/private']);
+%$
+%$ a = [1, 2];
+%$ b = [1, 4];
+%$
+%$ try
+%$     boolean = lessthan(a, b);
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$
+%$ if t(1)
+%$     t(2) = dassert(boolean, true);
+%$ end
+%$
+%$ T = all(t);
+%$ cd(OPATH);
+%@eof:4
+
+%@test:5
+%$ OPATH = pwd();
+%$ [DATES_PATH, junk1, junk2] = fileparts(which('dates'));
+%$ cd([DATES_PATH '/private']);
+%$
+%$ a = [1, 2];
+%$ b = [1, 2];
+%$
+%$ try
+%$     boolean = lessthan(a, b);
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$
+%$ if t(1)
+%$     t(2) = dassert(boolean, false);
+%$ end
+%$
+%$ T = all(t);
+%$ cd(OPATH);
+%@eof:5
diff --git a/src/@dates/strings.m b/src/@dates/strings.m
index 0198d15c1e69fcc354683e451f65c578bf2006ad..a6c9fc80c215db061e4ed99a5f395460b7d12100 100644
--- a/src/@dates/strings.m
+++ b/src/@dates/strings.m
@@ -1,4 +1,4 @@
-function m = strings(o)
+function m = strings(o) % --*-- Unitary tests --*--
 
 % Returns a cell array of strings containing the dates
 %
@@ -28,3 +28,28 @@ m = cell(1,o.ndat());
 for i = 1:o.length()
     m(i) = { date2string(o.time(i,:), o.freq) };
 end
+
+%@test:1
+%$ % Define a dates objects
+%$ d = dates('1950Q1'):dates('1950Q3');
+%$
+%$ % Call the tested routine.
+%$ try
+%$     m = strings(d);
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$
+%$ % Check the results.
+%$ if t(1)
+%$     t(2) = iscell(m);
+%$     t(3) = dassert(m{1}, '1950Q1');
+%$     t(4) = dassert(m{2}, '1950Q2');
+%$     t(5) = dassert(m{3}, '1950Q3');
+%$     t(6) = dassert(length(m), 3);
+%$ end
+%$
+%$ T = all(t);
+%@eof:1
+
diff --git a/src/@dates/subsasgn.m b/src/@dates/subsasgn.m
index b9cd166959d818de5c102c190fbae46e1d02a401..5a49f7918fff75baaa1f6fb89ccc54594298f3f1 100644
--- a/src/@dates/subsasgn.m
+++ b/src/@dates/subsasgn.m
@@ -1,4 +1,4 @@
-function val = subsasgn(val, idx, rhs)
+function val = subsasgn(val, idx, rhs) % --*-- Unitary tests --*--
 
 % Copyright (C) 2013-2014 Dynare Team
 %
@@ -15,4 +15,19 @@ function val = subsasgn(val, idx, rhs)
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-error('dates::subsasgn: Members of dates class are private')
\ No newline at end of file
+error('dates::subsasgn: Members of dates class are private')
+
+%@test:1
+%$ % Define a dates objects
+%$ d = dates('1950Q1'):dates('1950Q3');
+%$
+%$ % Call the tested routine.
+%$ try
+%$     d(1) = dates('1950Q4');
+%$     t(1) = false;
+%$ catch
+%$     t(1) = true;
+%$ end
+%$
+%$ T = all(t);
+%@eof:1
\ No newline at end of file
diff --git a/src/@dates/vertcat.m b/src/@dates/vertcat.m
index 82344e233e40e437ee1eb0bd1f9598668fa1964d..901d9753c80bade39026380e4acc65848e46f6a0 100644
--- a/src/@dates/vertcat.m
+++ b/src/@dates/vertcat.m
@@ -1,4 +1,4 @@
-function o = vertcat(varargin)
+function o = vertcat(varargin) % --*-- Unitary tests --*--
     
 % Overloads the vertcat method for dates objects.
 %
@@ -34,4 +34,53 @@ if ~all(cellfun(@isdates,varargin))
     error('dates:vertcat:ArgCheck','All input arguments must be dates objects.')
 end
     
-o = horzcat(varargin{:});
\ No newline at end of file
+o = horzcat(varargin{:});
+
+%@test:1
+%$ % Define some dates
+%$ B1 = '1953Q4';
+%$ B2 = '1950Q2';
+%$ B3 = '1950Q1';
+%$ B4 = '1945Q3';
+%$ B5 = '2009Q2';
+%$
+%$ % Define expected results.
+%$ e.time = [1945 3; 1950 1; 1950 2; 1953 4; 2009 2];
+%$ e.freq = 4;
+%$
+%$ % Call the tested routine.
+%$ d = dates(B4,B3,B2);
+%$ try
+%$     d = [d; dates(B1); dates(B5)];
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$
+%$ % Check the results.
+%$ if t(1)
+%$     t(2) = dassert(d.time,e.time);
+%$     t(3) = dassert(d.freq,e.freq);
+%$     t(4) = size(e.time,1)==d.ndat();
+%$ end
+%$
+%$ T = all(t);
+%@eof:1
+
+%@test:2
+%$ % Define some dates
+%$ B2 = '1950Q2';
+%$ B3 = '1950Q1';
+%$ B4 = '1945Q3';
+%$
+%$ % Call the tested routine.
+%$ d = dates(B4,B3,B2);
+%$ try
+%$     d = [d; 1];
+%$     t(1) = false;
+%$ catch
+%$     t(1) = true;
+%$ end
+%$
+%$ T = all(t);
+%@eof:2
diff --git a/src/utilities/convert/date2string.m b/src/utilities/convert/date2string.m
index ebf5c01a318d2c30839bfd4aa8796c149d2196d6..ad2a3a9311e7d4d1d318a20431b8d55805111178 100644
--- a/src/utilities/convert/date2string.m
+++ b/src/utilities/convert/date2string.m
@@ -1,4 +1,4 @@
-function s = date2string(varargin)
+function s = date2string(varargin) % --*-- Unitary tests --*--
  
 % Returns date as a string.
 %
@@ -51,4 +51,71 @@ end
 s = [num2str(time(1)) freq2string(freq)];
 if freq>1
     s = strcat(s, num2str(time(2)));
-end
\ No newline at end of file
+end
+
+%@test:1
+%$ try
+%$     str = date2string(dates('1938Q4'));
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$
+%$ if t(1)
+%$     t(2) = dassert(str, '1938Q4');
+%$ end
+%$
+%$ T = all(t);
+%@eof:1
+
+%@test:2
+%$ try
+%$     str = date2string(dates('1938Q4','1945Q3'));
+%$     t(1) = false;
+%$ catch
+%$     t(1) = true;
+%$ end
+%$
+%$ T = all(t);
+%@eof:2
+
+%@test:3
+%$ try
+%$     str = date2string([1938, 11], 12);
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$
+%$ if t(1)
+%$     t(2) = dassert(str, '1938M11');
+%$ end
+%$
+%$ T = all(t);
+%@eof:3
+
+%@test:4
+%$ try
+%$     str = date2string([1938; 11], 12);
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$
+%$ if t(1)
+%$     t(2) = dassert(str, '1938M11');
+%$ end
+%$
+%$ T = all(t);
+%@eof:4
+
+%@test:5
+%$ try
+%$     str = date2string([1938; 11], 4);
+%$     t(1) = false;
+%$ catch
+%$     t(1) = true;
+%$ end
+%$
+%$ T = all(t);
+%@eof:5
diff --git a/src/utilities/convert/freq2string.m b/src/utilities/convert/freq2string.m
index 2d12f8def073acc9e2d260b25a32a5c82eb346a3..b7a6873ececae0d1a67f1efd3fbd044898647645 100644
--- a/src/utilities/convert/freq2string.m
+++ b/src/utilities/convert/freq2string.m
@@ -1,4 +1,4 @@
-function s = freq2string(freq)
+function s = freq2string(freq) % --*-- Unitary tests --*--
 
 % INPUTS 
 %  o freq     scalar integer,  equal to 1, 4, 12 or 52 (resp. annual, quaterly, monthly or weekly)
@@ -34,4 +34,36 @@ switch freq
     s = 'W';
   otherwise
     error('dates::freq2string: Unknown frequency!')
-end
\ No newline at end of file
+end
+
+%@test:1
+%$ try
+%$     strY = freq2string(1);
+%$     strQ = freq2string(4);
+%$     strM = freq2string(12);
+%$     strW = freq2string(52);
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$
+%$ if t(1)
+%$     t(2) = dassert(strY, 'Y');
+%$     t(3) = dassert(strQ, 'Q');
+%$     t(4) = dassert(strM, 'M');
+%$     t(5) = dassert(strW, 'W');
+%$ end
+%$
+%$ T = all(t);
+%@eof:1
+
+%@test:2
+%$ try
+%$     str = freq2string(13);
+%$     t(1) = false;
+%$ catch
+%$     t(1) = true;
+%$ end
+%$
+%$ T = all(t);
+%@eof:2
diff --git a/src/utilities/convert/string2freq.m b/src/utilities/convert/string2freq.m
index ea04c39649e27a0f3555163d6e44ad612cc2009f..8ec1c14987f1c967ebc59abe91535574f4450332 100644
--- a/src/utilities/convert/string2freq.m
+++ b/src/utilities/convert/string2freq.m
@@ -1,4 +1,4 @@
-function freq = string2freq(s)
+function freq = string2freq(s) % --*-- Unitary tests --*--
 
 % INPUTS 
 %  o s        character, equal to Y, Q, M or W (resp. annual, quaterly, monthly or weekly)
@@ -34,4 +34,36 @@ switch upper(s)
     freq = 52;
   otherwise
     error('dates::freq2string: Unknown frequency!')
-end
\ No newline at end of file
+end
+
+%@test:1
+%$ try
+%$     nY = string2freq('Y');
+%$     nQ = string2freq('Q');
+%$     nM = string2freq('M');
+%$     nW = string2freq('W');
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$
+%$ if t(1)
+%$     t(2) = dassert(nY, 1);
+%$     t(3) = dassert(nQ, 4);
+%$     t(4) = dassert(nM, 12);
+%$     t(5) = dassert(nW, 52);
+%$ end
+%$
+%$ T = all(t);
+%@eof:1
+
+%@test:2
+%$ try
+%$     n = string2freq('Z');
+%$     t(1) = false;
+%$ catch
+%$     t(1) = true;
+%$ end
+%$
+%$ T = all(t);
+%@eof:2
diff --git a/src/utilities/is/isdates.m b/src/utilities/is/isdates.m
index 33b679020bb4b539593495456d17f504fc3c57b2..360eaf9e9f854a3263c476c3530ba93b5f9e336a 100644
--- a/src/utilities/is/isdates.m
+++ b/src/utilities/is/isdates.m
@@ -1,4 +1,4 @@
-function B = isdates(A)
+function B = isdates(A) % --*-- Unitary tests --*--
 
 % Tests if the input A is a dates object.
 
@@ -19,4 +19,79 @@ function B = isdates(A)
 % You should have received a copy of the GNU General Public License
 % along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 
-B = isa(A,'dates');
\ No newline at end of file
+B = isa(A,'dates');
+
+%@test:1
+%$ try
+%$     boolean = isdates(dates('1950Q2'));
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$
+%$ if t(1)
+%$     t(2) = dassert(boolean, true);
+%$ end
+%$
+%$ T = all(t);
+%@eof:1
+
+%@test:2
+%$ try
+%$     boolean = isdates(dates());
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$
+%$ if t(1)
+%$     t(2) = dassert(boolean, true);
+%$ end
+%$
+%$ T = all(t);
+%@eof:2
+
+%@test:3
+%$ try
+%$     boolean = isdates(dates('1950Q2'):dates('1950Q4'));
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$
+%$ if t(1)
+%$     t(2) = dassert(boolean, true);
+%$ end
+%$
+%$ T = all(t);
+%@eof:3
+
+%@test:4
+%$ try
+%$     boolean = isdates(1);
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$
+%$ if t(1)
+%$     t(2) = dassert(boolean, false);
+%$ end
+%$
+%$ T = all(t);
+%@eof:4
+
+%@test:5
+%$ try
+%$     boolean = isdates('1938M11');
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$
+%$ if t(1)
+%$     t(2) = dassert(boolean, false);
+%$ end
+%$
+%$ T = all(t);
+%@eof:5
\ No newline at end of file
diff --git a/src/utilities/is/isfreq.m b/src/utilities/is/isfreq.m
index f552bdca81e10f4e3686aae5fb433aea0a70699c..880c2049a68c94ea426be55ae9415ef23b4e3afd 100644
--- a/src/utilities/is/isfreq.m
+++ b/src/utilities/is/isfreq.m
@@ -1,4 +1,4 @@
-function B = isfreq(A)
+function B = isfreq(A) % --*-- Unitary tests --*--
 
 % Tests if A can be interpreted as a frequency.
 %
@@ -36,4 +36,79 @@ end
 
 if isnumeric(A) && isequal(length(A),1) && ismember(A,[1 4 12 52])
     B = true;
-end
\ No newline at end of file
+end
+
+%@test:1
+%$ try
+%$     boolean = isfreq('w');
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$
+%$ if t(1)
+%$     t(2) = dassert(boolean, true);
+%$ end
+%$
+%$ T = all(t);
+%@eof:1
+
+%@test:2
+%$ try
+%$     boolean = isfreq('W');
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$
+%$ if t(1)
+%$     t(2) = dassert(boolean, true);
+%$ end
+%$
+%$ T = all(t);
+%@eof:2
+
+%@test:3
+%$ try
+%$     boolean = isfreq('M');
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$
+%$ if t(1)
+%$     t(2) = dassert(boolean, true);
+%$ end
+%$
+%$ T = all(t);
+%@eof:3
+
+%@test:4
+%$ try
+%$     boolean = isfreq('Q');
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$
+%$ if t(1)
+%$     t(2) = dassert(boolean, true);
+%$ end
+%$
+%$ T = all(t);
+%@eof:4
+
+%@test:5
+%$ try
+%$     boolean = isfreq('Y');
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$
+%$ if t(1)
+%$     t(2) = dassert(boolean, true);
+%$ end
+%$
+%$ T = all(t);
+%@eof:5
diff --git a/src/utilities/is/issubperiod.m b/src/utilities/is/issubperiod.m
index 5f7a7560bcc7202a0712152a4c8f362334507e83..ec4dd1f5d0c33bff2bbf35df2ccbd2886e3334c8 100644
--- a/src/utilities/is/issubperiod.m
+++ b/src/utilities/is/issubperiod.m
@@ -1,4 +1,4 @@
-function C = issubperiod(A,B)
+function C = issubperiod(A,B) % --*-- Unitary tests --*--
 
 % Copyright (C) 2013 Dynare Team
 %
@@ -21,4 +21,49 @@ if isfreq(B)
     C = all(isint(A)) && all(A>=1) && all(A<=B);
 else
     error('issubperiod:: Second input argument must be equal to 1, 4, 12 or 52 (frequency)!')
-end
\ No newline at end of file
+end
+
+%@test:1
+%$ try
+%$    b = issubperiod(1, 1);
+%$    t(1) = true;
+%$ catch
+%$    t(1) = false;
+%$ end
+%$
+%$ if t(1)
+%$     t(2) = dassert(b, true);
+%$ end
+%$
+%$ T = all(t);
+%@eof:1
+
+%@test:2
+%$ try
+%$    b = issubperiod(2, 4);
+%$    t(1) = true;
+%$ catch
+%$    t(1) = false;
+%$ end
+%$
+%$ if t(1)
+%$     t(2) = dassert(b, true);
+%$ end
+%$
+%$ T = all(t);
+%@eof:2
+
+%@test:3
+%$ try
+%$    b = issubperiod(6, 4);
+%$    t(1) = true;
+%$ catch
+%$    t(1) = false;
+%$ end
+%$
+%$ if t(1)
+%$     t(2) = dassert(b, false);
+%$ end
+%$
+%$ T = all(t);
+%@eof:3
\ No newline at end of file
diff --git a/src/utilities/missing/isint/isint.m b/src/utilities/missing/isint/isint.m
index 482d34b334e37a0b36b9c41b9a25739cd9db2672..73417cc47a2ea601c2f821b070063919df608ba6 100644
--- a/src/utilities/missing/isint/isint.m
+++ b/src/utilities/missing/isint/isint.m
@@ -42,4 +42,88 @@ l = abs(fix(a)-a)<1e-15;
 if nargout>1
     c = find(l==true);
     d = find(l==false);
-end
\ No newline at end of file
+end
+
+%@test:1
+%$ a = 1938;
+%$ try
+%$     boolean = isint(a);
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$
+%$ if t(1)
+%$     t(2) = dassert(boolean, true);
+%$ end
+%$
+%$ T = all(t);
+%@eof:1
+
+%@test:2
+%$ a = pi;
+%$ try
+%$     boolean = isint(a);
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$
+%$ if t(1)
+%$     t(2) = dassert(boolean, false);
+%$ end
+%$
+%$ T = all(t);
+%@eof:2
+
+%@test:3
+%$ a = '1';
+%$ try
+%$     boolean = isint(a);
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$
+%$ if t(1)
+%$     t(2) = dassert(boolean, false);
+%$ end
+%$
+%$ T = all(t);
+%@eof:3
+
+%@test:4
+%$ a = [1; 2; 3];
+%$ try
+%$     [boolean, iV, iF]  = isint(a);
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$
+%$ if t(1)
+%$     t(2) = dassert(all(boolean), true);
+%$     t(3) = dassert(isequal(iV, [1; 2; 3]), true);
+%$     t(4) = dassert(isempty(iF), true);
+%$ end
+%$
+%$ T = all(t);
+%@eof:4
+
+%@test:5
+%$ a = [1; pi; 3];
+%$ try
+%$     [boolean, iV, iF]  = isint(a);
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$
+%$ if t(1)
+%$     t(2) = dassert(all(boolean), false);
+%$     t(3) = dassert(isequal(iV, [1; 3]), true);
+%$     t(4) = dassert(isequal(iF, 2), true);
+%$ end
+%$
+%$ T = all(t);
+%@eof:5
\ No newline at end of file
diff --git a/src/utilities/missing/shiftS/shiftS.m b/src/utilities/missing/shiftS/shiftS.m
index 2ebd4aa10a18ee3258586761a821779b310482ee..c0c77e5b5a87c4839bb5404c476afce523612c1a 100644
--- a/src/utilities/missing/shiftS/shiftS.m
+++ b/src/utilities/missing/shiftS/shiftS.m
@@ -1,4 +1,4 @@
-function S = shiftS(S,n)
+function S = shiftS(S,n) % --*-- Unitary tests --*--
 
 % Removes the first n elements of a one dimensional cell array.
 
@@ -21,4 +21,39 @@ if length(S) >= n+1
     S = S(n+1:end);
 else
     S = {};
-end
\ No newline at end of file
+end
+
+%@test:1
+%$ Cell = {'1', '2', '3'};
+%$ try
+%$     Cell = shiftS(Cell,1);
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$
+%$ if t(1)
+%$     t(2) = dassert(length(Cell), 2);
+%$     t(3) = dassert(Cell, {'2', '3'});
+%$ end
+%$
+%$ T = all(t);
+%@eof:1
+
+%@test:1
+%$ Cell = {'1', '2', '3'};
+%$ try
+%$     Cell = shiftS(Cell,3);
+%$     t(1) = true;
+%$ catch
+%$     t(1) = false;
+%$ end
+%$
+%$ if t(1)
+%$     t(2) = dassert(length(Cell), 0);
+%$     t(3) = dassert(isequal(Cell, {}), true);
+%$ end
+%$
+%$ T = all(t);
+%@eof:1
+