lobo/isync
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
3c0ad89a13
isync/src/run-tests.pl

1326 lines
30 KiB
Perl
Raw Normal View History

add some regression testing.
2005-12-22 18:06:25 +00:00
#! /usr/bin/perl -w
add copyright + license
2006-02-11 19:48:44 +00:00
#
convert licensing to SPDX while at it, add/fix some licenses/copyrights/comments: - it makes no sense to have a GPL exception in scripts - ted did not contribute to the man page - tst_timers is not part of the mbsync executable - explicitly put the build system under GPL and add copyrights
2022-06-16 10:44:35 +00:00
# SPDX-FileCopyrightText: 2006-2022 Oswald Buddenhagen <ossi@users.sf.net>
# SPDX-License-Identifier: GPL-2.0-or-later
add copyright + license
2006-02-11 19:48:44 +00:00
#
add some regression testing.
2005-12-22 18:06:25 +00:00
autotest: use warnings
2017-03-14 10:10:35 +00:00
use warnings;
add some regression testing.
2005-12-22 18:06:25 +00:00
use strict;
autotest: be more verbose about internal errors & warnings
2022-01-25 20:45:06 +00:00
use Carp;
$SIG{__WARN__} = \&Carp::cluck;
$SIG{__DIE__} = \&Carp::confess;
autotest: determine path of mbsync prior to chdir() that allows tmp/ to be a symlink to a ramdisk.
2017-03-14 14:01:13 +00:00
use Cwd;
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
use Clone 'clone';
add some regression testing.
2005-12-22 18:06:25 +00:00
use File::Path;
autotest: create the temp dir in $TEMP on modern systems, this makes it likely to end up on tmpfs, which is a lot faster and ssd-friendlier. the symlink is not deleted at the end, to minimize fs churn. that means it will be dangling after a reboot, which gets fixed in the next run.
2019-12-29 10:59:05 +00:00
use File::Temp 'tempdir';
add some regression testing.
2005-12-22 18:06:25 +00:00
autotest: improve valgrind integration introduce recognition of $USE_VALGRIND to run all mbsync invocations through valgrind. this also removes the seemingly purposeless --log-fd=3 indirection.
2017-03-26 19:06:11 +00:00
my $use_vg = $ENV{USE_VALGRIND};
autotest: add support for strace-ing works just like valgrind-ing.
2022-04-04 19:51:16 +00:00
my $use_st = $ENV{USE_STRACE};
autotest: determine path of mbsync prior to chdir() that allows tmp/ to be a symlink to a ramdisk.
2017-03-14 14:01:13 +00:00
my $mbsync = getcwd()."/mbsync";
autotest: add support for starting at a specific test ... which is often useful for continuation after test data fixes.
2022-01-26 17:46:58 +00:00
my (@match, $start);
for my $arg (@ARGV) {
if ($arg eq "+") {
$start = 1;
} else {
push @match, $arg;
}
}
die("Need exactly one test name when using start syntax.\n")
if ($start && (@match != 1));
autotest: create the temp dir in $TEMP on modern systems, this makes it likely to end up on tmpfs, which is a lot faster and ssd-friendlier. the symlink is not deleted at the end, to minimize fs churn. that means it will be dangling after a reboot, which gets fixed in the next run.
2019-12-29 10:59:05 +00:00
if (!-d "tmp") {
unlink "tmp";
my $tdir = tempdir();
symlink $tdir, "tmp" or die "Cannot symlink temp directory: $!\n";
}
add some regression testing.
2005-12-22 18:06:25 +00:00
chdir "tmp" or die "Cannot enter temp direcory.\n";
autotest: use symbolic message subjects ... instead of numbers. otherwise there is too much confusion with UIDs.
2020-04-02 18:39:07 +00:00
use enum qw(:=1 A..Z);
autotest: make state comparison more elaborate don't abort the comparison if continuing makes sense, and try to be more specific about the problems. we give up if messages are excessive/missing or the subject is wrong, as that touches upon the rather complex problem of diff optimization.
2022-01-27 13:22:29 +00:00
sub mn($) { my ($n) = @_; $n == 0 ? "0" : chr(64 + $n) }
sub mf($) { my ($f) = @_; length($f) ? $f : '-' }
autotest: use symbolic message subjects ... instead of numbers. otherwise there is too much confusion with UIDs.
2020-04-02 18:39:07 +00:00
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
my $sync_flags = "<>^~DFPRST";
my $msg_flags = "DFPRST*?";
create placeholders for messages over MaxSize this is vastly more useful than just omitting the messages with no indication at all.
2019-12-29 13:37:53 +00:00
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
sub process_flag_add($$$$$$)
{
my ($flgr, $add, $ok_flags, $num, $e, $what) = @_;
return if ($add eq "");
for my $flg (split('', $add)) {
die("Adding invalid flag '$flg' for $what ".mn($num)." (at $e).\n")
if (index($ok_flags, $flg) < 0);
my $i = index($$flgr, $flg);
die("Adding duplicate flag '$flg' to $what ".mn($num)." (at $e).\n")
if ($i >= 0);
$$flgr .= $flg;
}
$$flgr = $ok_flags =~ s/[^$$flgr]//gr; # sort
}
create placeholders for messages over MaxSize this is vastly more useful than just omitting the messages with no indication at all.
2019-12-29 13:37:53 +00:00
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
sub process_flag_del($$$$$)
{
my ($flgr, $del, $num, $e, $what) = @_;
create placeholders for messages over MaxSize this is vastly more useful than just omitting the messages with no indication at all.
2019-12-29 13:37:53 +00:00
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
for my $flg (split('', $del)) {
my $i = index($$flgr, $flg);
die("Removing absent flag '$flg' from $what ".mn($num)." (at $e).\n")
if ($i < 0);
substr($$flgr, $i, 1) = '';
}
}
create placeholders for messages over MaxSize this is vastly more useful than just omitting the messages with no indication at all.
2019-12-29 13:37:53 +00:00
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
sub process_flag_update($$$$$$$)
{
my ($flgr, $add, $del, $ok_flags, $num, $e, $what) = @_;
create placeholders for messages over MaxSize this is vastly more useful than just omitting the messages with no indication at all.
2019-12-29 13:37:53 +00:00
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
process_flag_del($flgr, $del, $num, $e, $what);
process_flag_add($flgr, $add, $ok_flags, $num, $e, $what);
}
add MaxSize tests
2005-12-26 16:01:42 +00:00
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
sub parse_flags($$$$$)
{
my ($rflg, $ok_flags, $num, $e, $what) = @_;
add expiration tests
2005-12-26 16:02:08 +00:00
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
my $add = $$rflg;
$$rflg = "";
process_flag_add($rflg, $add, $ok_flags, $num, $e, $what);
}
add expiration tests
2005-12-26 16:02:08 +00:00
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
sub parse_flag_update($)
{
my ($stsr) = @_;
add expiration tests
2005-12-26 16:02:08 +00:00
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
my ($add, $del) = ("", "");
while ($$stsr =~ s,^([-+])([^-+]+),,) {
if ($1 eq "+") {
$add .= $2;
} else {
$del .= $2;
}
}
return ($add, $del);
}
add ExpireUnread option
2013-11-24 19:26:33 +00:00
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
# Returns UID.
sub create_msg($$$$$)
{
my ($num, $flg, $bs, $t, $e) = @_;
add expiration tests
2005-12-26 16:02:08 +00:00
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
my ($mur, $msr, $n2ur) = (\$$bs{max_uid}, $$bs{messages}, $$bs{num2uid});
$$mur++;
if ($flg ne "_") {
parse_flags(\$flg, $msg_flags, $num, $e, "$t side");
$$msr{$$mur} = [ $num, $flg ];
}
push @{$$n2ur{$num}}, $$mur;
return $$mur;
}
add expiration tests
2005-12-26 16:02:08 +00:00
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
# Returns old UID, new UID.
sub parse_msg($$$$$)
{
my ($num, $sts, $cs, $t, $e) = @_;
my $bs = $$cs{$t};
my ($msr, $n2ur) = ($$bs{messages}, $$bs{num2uid});
add autotest for message trashing
2022-04-04 16:55:14 +00:00
$$cs{"${t}_trash"}{$num} = 1
if ($sts =~ s,^#,,);
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
my $ouid;
my $uids = \@{$$n2ur{$num}};
if ($sts =~ s,^&$,,) {
$ouid = 0;
} elsif ($sts =~ s,^&(\d+),,) {
my $n = int($1);
die("Referencing unrecognized instance $n of message ".mn($num)." on $t side (at $e).\n")
if (!$n || $n > @$uids);
$ouid = $$uids[$n - 1];
} else {
$ouid = @$uids ? $$uids[-1] : 0;
}
my $nuid = ($sts =~ s,^\|,,) ? 0 : $ouid;
if ($sts eq "_" or $sts =~ s,^\*,,) {
die("Adding already present message ".mn($num)." on $t side (at $e).\n")
if (defined($$msr{$ouid}));
$nuid = create_msg($num, $sts, $bs, $t, $e);
} elsif ($sts =~ s,^\^,,) {
die("Duplicating absent message ".mn($num)." on $t side (at $e).\n")
if (!defined($$msr{$ouid}));
$nuid = create_msg($num, $sts, $bs, $t, $e);
} elsif ($sts eq "/") {
# Note that we don't delete $$n2ur{$num}, as state entries may
# refer to expunged messages. Subject re-use is not supported here.
die("Deleting absent message ".mn($num)." from $t side (at $e).\n")
if (!delete $$msr{$ouid});
$nuid = 0;
} elsif ($sts ne "") {
my ($add, $del) = parse_flag_update(\$sts);
die("Unrecognized message command '$sts' for $t side (at $e).\n")
if ($sts ne "");
die("No message ".mn($num)." present on $t side (at $e).\n")
if (!defined($$msr{$ouid}));
process_flag_update(\$$msr{$ouid}[1], $add, $del, $msg_flags, $num, $e, "$t side");
}
return $ouid, $nuid;
}
add expiration tests
2005-12-26 16:02:08 +00:00
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
# Returns UID.
sub resolv_msg($$$)
{
my ($num, $cs, $t) = @_;
add some regression testing.
2005-12-22 18:06:25 +00:00
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
return 0 if (!$num);
my $uids = \@{$$cs{$t}{num2uid}{$num}};
die("No message ".mn($num)." present on $t side (in header).\n")
if (!@$uids);
return $$uids[-1];
}
add some regression testing.
2005-12-22 18:06:25 +00:00
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
# Returns index, or undef if not found.
sub find_ent($$$)
autotest: use more appropriate data formats parse the test data into hierarchical structures instead of using it in its raw form. this is semantically cleaner and allows us to change the input format more easily.
2022-01-23 23:33:53 +00:00
{
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
my ($fu, $nu, $ents) = @_;
autotest: use more appropriate data formats parse the test data into hierarchical structures instead of using it in its raw form. this is semantically cleaner and allows us to change the input format more easily.
2022-01-23 23:33:53 +00:00
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
for (my $i = 0; $i < @$ents; $i++) {
my $ent = $$ents[$i];
return $i if ($$ent[0] == $fu and $$ent[1] == $nu);
autotest: use more appropriate data formats parse the test data into hierarchical structures instead of using it in its raw form. this is semantically cleaner and allows us to change the input format more easily.
2022-01-23 23:33:53 +00:00
}
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
return undef;
autotest: use more appropriate data formats parse the test data into hierarchical structures instead of using it in its raw form. this is semantically cleaner and allows us to change the input format more easily.
2022-01-23 23:33:53 +00:00
}
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
sub find_ent_chk($$$$$)
autotest: use more appropriate data formats parse the test data into hierarchical structures instead of using it in its raw form. this is semantically cleaner and allows us to change the input format more easily.
2022-01-23 23:33:53 +00:00
{
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
my ($fu, $nu, $cs, $num, $e) = @_;
autotest: use more appropriate data formats parse the test data into hierarchical structures instead of using it in its raw form. this is semantically cleaner and allows us to change the input format more easily.
2022-01-23 23:33:53 +00:00
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
my $enti = find_ent($fu, $nu, $$cs{state}{entries});
die("No state entry $fu:$nu present for ".mn($num)." (at $e).\n")
if (!defined($enti));
return $enti;
autotest: use more appropriate data formats parse the test data into hierarchical structures instead of using it in its raw form. this is semantically cleaner and allows us to change the input format more easily.
2022-01-23 23:33:53 +00:00
}
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
sub parse_chan($;$)
autotest: use more appropriate data formats parse the test data into hierarchical structures instead of using it in its raw form. this is semantically cleaner and allows us to change the input format more easily.
2022-01-23 23:33:53 +00:00
{
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
my ($ics, $ref) = @_;
autotest: use more appropriate data formats parse the test data into hierarchical structures instead of using it in its raw form. this is semantically cleaner and allows us to change the input format more easily.
2022-01-23 23:33:53 +00:00
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
my $cs;
if ($ref) {
$cs = clone($ref);
} else {
$cs = {
# messages: { uid => [ subject, flags ], ... }
far => { max_uid => 0, messages => {}, num2uid => {} },
near => { max_uid => 0, messages => {}, num2uid => {} },
add autotest for message trashing
2022-04-04 16:55:14 +00:00
# trashed messages: { subject => is_placeholder, ... }
far_trash => { },
near_trash => { },
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
# entries: [ [ far_uid, near_uid, flags ], ... ]
state => { entries => [] }
};
}
my $ss = $$cs{state};
my $ents = $$ss{entries};
my $enti;
for (my ($i, $e) = (3, 1); $i < @$ics; $i += 4, $e++) {
my ($num, $far, $sts, $near) = @{$ics}[$i .. $i+3];
my ($ofu, $nfu) = parse_msg($num, $far, $cs, "far", $e);
my ($onu, $nnu) = parse_msg($num, $near, $cs, "near", $e);
if ($sts =~ s,^\*,,) {
$enti = find_ent($nfu, $nnu, $ents);
die("State entry $nfu:$nnu already present for ".mn($num)." (at $e).\n")
if (defined($enti));
parse_flags(\$sts, $sync_flags, $num, $e, "sync entry");
push @$ents, [ $nfu, $nnu, $sts ];
} elsif ($sts =~ s,^\^,,) {
die("No current state entry for ".mn($num)." (at $e).\n")
if (!defined($enti));
parse_flags(\$sts, $sync_flags, $num, $e, "sync entry");
splice @$ents, $enti++, 0, ([ $nfu, $nnu, $sts ]);
} elsif ($sts eq "/") {
$enti = find_ent_chk($ofu, $onu, $cs, $num, $e);
splice @$ents, $enti, 1;
} elsif ($sts ne "") {
my $t = -1;
if ($sts =~ s,^<,,) {
$t = 0;
} elsif ($sts =~ s,^>,,) {
$t = 1;
}
my ($add, $del) = parse_flag_update(\$sts);
die("Unrecognized state command '".$sts."' for ".mn($num)." (at $e).\n")
if ($sts ne "");
$enti = find_ent_chk($ofu, $onu, $cs, $num, $e);
my $ent = $$ents[$enti++];
process_flag_update(\$$ent[2], $add, $del, $sync_flags, $num, $e, "sync entry");
if ($t >= 0) {
my $uid = $t ? $nnu : $nfu;
$$ent[$t] = ($uid && $$cs{$t ? "near" : "far"}{messages}{$uid}) ? $uid : 0;
}
} else {
$enti = undef;
}
}
$$ss{max_pulled} = resolv_msg($$ics[0], $cs, "far");
$$ss{max_expired} = resolv_msg($$ics[1], $cs, "far");
$$ss{max_pushed} = resolv_msg($$ics[2], $cs, "near");
return $cs;
autotest: use more appropriate data formats parse the test data into hierarchical structures instead of using it in its raw form. this is semantically cleaner and allows us to change the input format more easily.
2022-01-23 23:33:53 +00:00
}
add some regression testing.
2005-12-22 18:06:25 +00:00
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
add some regression testing.
2005-12-22 18:06:25 +00:00
sub qm($)
{
shift;
s/\\/\\\\/g;
s/\"/\\"/g;
s/\"/\\"/g;
s/\n/\\n/g;
return $_;
}
autotest: pass containers by reference this makes function prototypes a lot more useful for parameter checking.
2020-12-18 13:31:16 +00:00
# [ $far, $near, $channel ]
sub writecfg($)
add some regression testing.
2005-12-22 18:06:25 +00:00
{
autotest: pass containers by reference this makes function prototypes a lot more useful for parameter checking.
2020-12-18 13:31:16 +00:00
my ($sfx) = @_;
add some regression testing.
2005-12-22 18:06:25 +00:00
open(FILE, ">", ".mbsyncrc") or
die "Cannot open .mbsyncrc.\n";
print FILE
reduce FSync option to a boolean there is no use for Thorough mode any more, so simplify the configuration.
2013-11-02 20:42:34 +00:00
"FSync no
add option to control amount of fsync()ing
2012-09-15 13:15:22 +00:00
deprecate master/slave terminology the underlying metaphor refers to an inhumane practice, so using it casually is rightfully offensive to many people. it isn't even a particularly apt metaphor, as it suggests a strict hierarchy that is counter to mbsync's highly symmetrical mode of operation. the far/near terminology has been chosen as the replacement, as it is a natural fit for the push/pull terminology. on the downside, due to these not being nouns, a few uses are a bit awkward, and several others had to be amended to include 'side'. also, it's conceptually quite close to remote/local, which matches the typical use case, but is maybe a bit too suggestive of actually non-existing limitations. the new f/n suffixes of the -C/-R/-X options clash with pre-existing options, so direct concatenation of short options is even less practical than before (some suffixes of -D already clashed), but doing that leads to unreadable command lines anyway. as with previous deprecations, all pre-existing command line and config options keep working, but yield a warning. the state files are silently upgraded.
2020-07-22 17:44:26 +00:00
MaildirStore far
re-interpret relative local paths in config file this makes config+data file "sets" relocatable, which is useful for testing. this is technically a gratuitous backwards incompatible behavior change, but to the degree that anyone uses relative paths at all, they almost certainly rely on PWD being set up such that they won't see a difference.
2022-05-30 21:04:52 +00:00
Path \"\"
Inbox far
autotest: pass containers by reference this makes function prototypes a lot more useful for parameter checking.
2020-12-18 13:31:16 +00:00
".$$sfx[0]."
deprecate master/slave terminology the underlying metaphor refers to an inhumane practice, so using it casually is rightfully offensive to many people. it isn't even a particularly apt metaphor, as it suggests a strict hierarchy that is counter to mbsync's highly symmetrical mode of operation. the far/near terminology has been chosen as the replacement, as it is a natural fit for the push/pull terminology. on the downside, due to these not being nouns, a few uses are a bit awkward, and several others had to be amended to include 'side'. also, it's conceptually quite close to remote/local, which matches the typical use case, but is maybe a bit too suggestive of actually non-existing limitations. the new f/n suffixes of the -C/-R/-X options clash with pre-existing options, so direct concatenation of short options is even less practical than before (some suffixes of -D already clashed), but doing that leads to unreadable command lines anyway. as with previous deprecations, all pre-existing command line and config options keep working, but yield a warning. the state files are silently upgraded.
2020-07-22 17:44:26 +00:00
MaildirStore near
re-interpret relative local paths in config file this makes config+data file "sets" relocatable, which is useful for testing. this is technically a gratuitous backwards incompatible behavior change, but to the degree that anyone uses relative paths at all, they almost certainly rely on PWD being set up such that they won't see a difference.
2022-05-30 21:04:52 +00:00
Path \"\"
Inbox near
autotest: pass containers by reference this makes function prototypes a lot more useful for parameter checking.
2020-12-18 13:31:16 +00:00
".$$sfx[1]."
add some regression testing.
2005-12-22 18:06:25 +00:00
Channel test
deprecate master/slave terminology the underlying metaphor refers to an inhumane practice, so using it casually is rightfully offensive to many people. it isn't even a particularly apt metaphor, as it suggests a strict hierarchy that is counter to mbsync's highly symmetrical mode of operation. the far/near terminology has been chosen as the replacement, as it is a natural fit for the push/pull terminology. on the downside, due to these not being nouns, a few uses are a bit awkward, and several others had to be amended to include 'side'. also, it's conceptually quite close to remote/local, which matches the typical use case, but is maybe a bit too suggestive of actually non-existing limitations. the new f/n suffixes of the -C/-R/-X options clash with pre-existing options, so direct concatenation of short options is even less practical than before (some suffixes of -D already clashed), but doing that leads to unreadable command lines anyway. as with previous deprecations, all pre-existing command line and config options keep working, but yield a warning. the state files are silently upgraded.
2020-07-22 17:44:26 +00:00
Far :far:
Near :near:
add some regression testing.
2005-12-22 18:06:25 +00:00
SyncState *
autotest: pass containers by reference this makes function prototypes a lot more useful for parameter checking.
2020-12-18 13:31:16 +00:00
".$$sfx[2];
add some regression testing.
2005-12-22 18:06:25 +00:00
close FILE;
much improved journal replay testing. some clenup.
2006-02-02 10:25:07 +00:00
}
sub killcfg()
{
autotest: write logs to files they can get long, and having actual files also helps with diffing.
2017-03-29 14:31:32 +00:00
unlink $_ for (glob("*.log"));
add some regression testing.
2005-12-22 18:06:25 +00:00
unlink ".mbsyncrc";
much improved journal replay testing. some clenup.
2006-02-02 10:25:07 +00:00
}
add forced async mode to proxy driver to test async operation of the syncing core while using the synchronous maildir driver, we add a mode to the proxy driver where it queues callback invocations to the next main loop iteration.
2020-12-14 22:16:01 +00:00
# $run_async, $mbsync_options, $log_file
autotest: pass containers by reference this makes function prototypes a lot more useful for parameter checking.
2020-12-18 13:31:16 +00:00
# Return: $exit_code, \@mbsync_output
add forced async mode to proxy driver to test async operation of the syncing core while using the synchronous maildir driver, we add a mode to the proxy driver where it queues callback invocations to the next main loop iteration.
2020-12-14 22:16:01 +00:00
sub runsync($$$)
much improved journal replay testing. some clenup.
2006-02-02 10:25:07 +00:00
{
add forced async mode to proxy driver to test async operation of the syncing core while using the synchronous maildir driver, we add a mode to the proxy driver where it queues callback invocations to the next main loop iteration.
2020-12-14 22:16:01 +00:00
my ($async, $flags, $file) = @_;
autotest: write logs to files they can get long, and having actual files also helps with diffing.
2017-03-29 14:31:32 +00:00
autotest: improve valgrind integration introduce recognition of $USE_VALGRIND to run all mbsync invocations through valgrind. this also removes the seemingly purposeless --log-fd=3 indirection.
2017-03-26 19:06:11 +00:00
my $cmd;
if ($use_vg) {
$cmd = "valgrind -q --error-exitcode=1 ";
autotest: add support for strace-ing works just like valgrind-ing.
2022-04-04 19:51:16 +00:00
} elsif ($use_st) {
$cmd = "strace ";
autotest: improve valgrind integration introduce recognition of $USE_VALGRIND to run all mbsync invocations through valgrind. this also removes the seemingly purposeless --log-fd=3 indirection.
2017-03-26 19:06:11 +00:00
} else {
$flags .= " -D";
}
test also one-sided async operation this tests only the common case of the far side being async - adding 100% instead of 50% to the runtime of the test to cover a corner case didn't seem worth it.
2022-06-01 11:54:48 +00:00
if ($async == 2) {
$flags .= " -TA";
} elsif ($async == 1) {
$flags .= " -Ta";
}
consolidate testing options behind common switch don't pollute the namespace with random uppercase switches. instead, have a new -T switch with suboptions, just like -D.
2020-12-16 12:49:27 +00:00
$cmd .= "$mbsync -Tz $flags -c .mbsyncrc test";
autotest: improve valgrind integration introduce recognition of $USE_VALGRIND to run all mbsync invocations through valgrind. this also removes the seemingly purposeless --log-fd=3 indirection.
2017-03-26 19:06:11 +00:00
open FILE, "$cmd 2>&1 |";
much improved journal replay testing. some clenup.
2006-02-02 10:25:07 +00:00
my @out = <FILE>;
close FILE or push(@out, $! ? "*** error closing mbsync: $!\n" : "*** mbsync exited with signal ".($?&127).", code ".($?>>8)."\n");
autotest: write logs to files they can get long, and having actual files also helps with diffing.
2017-03-29 14:31:32 +00:00
if ($file) {
open FILE, ">$file" or die("Cannot create $file: $!\n");
print FILE @out;
close FILE;
}
autotest: pass containers by reference this makes function prototypes a lot more useful for parameter checking.
2020-12-18 13:31:16 +00:00
return $?, \@out;
add some regression testing.
2005-12-22 18:06:25 +00:00
}
much improved journal replay testing. some clenup.
2006-02-02 10:25:07 +00:00
autotest: make more use of readfile()
2022-02-07 14:44:38 +00:00
use constant CHOMP => 1;
sub readfile($;$)
{
my ($file, $chomp) = @_;
open(FILE, $file) or return;
my @nj = <FILE>;
close FILE;
chomp(@nj) if ($chomp);
return \@nj;
}
add some regression testing.
2005-12-22 18:06:25 +00:00
# $path
add autotest for message trashing
2022-04-04 16:55:14 +00:00
sub readbox_impl($$)
add some regression testing.
2005-12-22 18:06:25 +00:00
{
add autotest for message trashing
2022-04-04 16:55:14 +00:00
my ($bn, $cb) = @_;
add some regression testing.
2005-12-22 18:06:25 +00:00
(-d $bn."/tmp" and -d $bn."/new" and -d $bn."/cur") or
die "Invalid mailbox '$bn'.\n";
for my $d ("cur", "new") {
opendir(DIR, $bn."/".$d) or next;
for my $f (grep(!/^\.\.?$/, readdir(DIR))) {
open(FILE, "<", $bn."/".$d."/".$f) or die "Cannot read message '$f' in '$bn'.\n";
add autotest for message trashing
2022-04-04 16:55:14 +00:00
my ($sz, $num, $ph) = (0);
add some regression testing.
2005-12-22 18:06:25 +00:00
while (<FILE>) {
autotest: use ints where we mean ints ... instead of using strings. perl allows being sloppy, but it doesn't really help understanding the code.
2022-01-24 20:49:18 +00:00
/^Subject: (\[placeholder\] )?(\d+)$/ && ($ph = defined($1), $num = int($2));
add MaxSize tests
2005-12-26 16:01:42 +00:00
$sz += length($_);
add some regression testing.
2005-12-22 18:06:25 +00:00
}
close FILE;
if (!defined($num)) {
print STDERR "message '$f' in '$bn' has no identifier.\n";
exit 1;
}
add autotest for message trashing
2022-04-04 16:55:14 +00:00
$cb->($num, $ph, $sz, $f);
add some regression testing.
2005-12-22 18:06:25 +00:00
}
}
add autotest for message trashing
2022-04-04 16:55:14 +00:00
}
# $path
sub readbox($)
{
my $bn = shift;
(-d $bn) or
die "No mailbox '$bn'.\n";
my %ms;
readbox_impl($bn, sub {
my ($num, $ph, $sz, $f) = @_;
if ($f !~ /^\d+\.\d+_\d+\.[-[:alnum:]]+,U=(\d+):2,(.*)$/) {
print STDERR "unrecognided file name '$f' in '$bn'.\n";
exit 1;
}
my ($uid, $flg) = (int($1), $2);
@{$ms{$uid}} = ($num, $flg.($sz > 1000 ? "*" : "").($ph ? "?" : ""));
});
my $uidval = readfile($bn."/.uidvalidity", CHOMP);
die "Cannot read UID validity of mailbox '$bn': $!\n" if (!$uidval);
my $mu = $$uidval[1];
autotest: use more appropriate data formats parse the test data into hierarchical structures instead of using it in its raw form. this is semantically cleaner and allows us to change the input format more easily.
2022-01-23 23:33:53 +00:00
return { max_uid => $mu, messages => \%ms };
add some regression testing.
2005-12-22 18:06:25 +00:00
}
add autotest for message trashing
2022-04-04 16:55:14 +00:00
# $path
sub readtrash($)
{
my $bn = shift;
(-d $bn) or
return {};
my %ms;
readbox_impl($bn, sub {
my ($num, $ph, undef, undef) = @_;
$ms{$num} = $ph;
});
return \%ms;
}
autotest: support tests that don't modify the state file a test run may (legitimately or not) modify only the mailboxes, or even nothing at all. do something sensible in this case.
2022-01-26 20:56:50 +00:00
# \%fallback_sync_state
sub readstate(;$)
autotest: factor out readstate() from showstate() and ckstate()
2022-01-24 00:12:49 +00:00
{
autotest: support tests that don't modify the state file a test run may (legitimately or not) modify only the mailboxes, or even nothing at all. do something sensible in this case.
2022-01-26 20:56:50 +00:00
my ($fbss) = @_;
autotest: factor out readstate() from showstate() and ckstate()
2022-01-24 00:12:49 +00:00
autotest: support tests that don't modify the state file a test run may (legitimately or not) modify only the mailboxes, or even nothing at all. do something sensible in this case.
2022-01-26 20:56:50 +00:00
my $fn = "near/.mbsyncstate";
if ($fbss) {
$fn .= ".new";
return $fbss if (!-s $fn);
}
autotest: factor out readstate() from showstate() and ckstate()
2022-01-24 00:12:49 +00:00
my $ls = readfile($fn, CHOMP);
if (!$ls) {
print STDERR "Cannot read sync state $fn: $!\n";
return;
}
autotest: use more appropriate data formats parse the test data into hierarchical structures instead of using it in its raw form. this is semantically cleaner and allows us to change the input format more easily.
2022-01-23 23:33:53 +00:00
my @ents;
my %ss = (
max_pulled => 0,
max_expired => 0,
max_pushed => 0,
entries => \@ents
);
autotest: factor out readstate() from showstate() and ckstate()
2022-01-24 00:12:49 +00:00
my ($far_val, $near_val) = (0, 0);
my %hdr = (
'FarUidValidity' => \$far_val,
'NearUidValidity' => \$near_val,
autotest: use more appropriate data formats parse the test data into hierarchical structures instead of using it in its raw form. this is semantically cleaner and allows us to change the input format more easily.
2022-01-23 23:33:53 +00:00
'MaxPulledUid' => \$ss{max_pulled},
'MaxPushedUid' => \$ss{max_pushed},
'MaxExpiredFarUid' => \$ss{max_expired}
autotest: factor out readstate() from showstate() and ckstate()
2022-01-24 00:12:49 +00:00
);
OUTER: while (1) {
while (@$ls) {
$_ = shift(@$ls);
last OUTER if (!length($_));
if (!/^([^ ]+) (\d+)$/) {
print STDERR "Malformed sync state header entry: $_\n";
return;
}
my $want = delete $hdr{$1};
if (!defined($want)) {
print STDERR "Unexpected sync state header entry: $1\n";
return;
}
autotest: use ints where we mean ints ... instead of using strings. perl allows being sloppy, but it doesn't really help understanding the code.
2022-01-24 20:49:18 +00:00
$$want = int($2);
autotest: factor out readstate() from showstate() and ckstate()
2022-01-24 00:12:49 +00:00
}
print STDERR "Unterminated sync state header.\n";
return;
}
delete $hdr{'MaxExpiredFarUid'}; # optional field
my @ky = keys %hdr;
if (@ky) {
print STDERR "Keys missing from sync state header: @ky\n";
return;
}
if ($far_val ne '1' or $near_val ne '1') {
print STDERR "Unexpected UID validity $far_val $near_val (instead of 1 1)\n";
return;
}
for (@$ls) {
if (!/^(\d+) (\d+) (.*)$/) {
print STDERR "Malformed sync state entry: $_\n";
return;
}
autotest: use ints where we mean ints ... instead of using strings. perl allows being sloppy, but it doesn't really help understanding the code.
2022-01-24 20:49:18 +00:00
push @ents, [ int($1), int($2), $3 ];
autotest: factor out readstate() from showstate() and ckstate()
2022-01-24 00:12:49 +00:00
}
autotest: use more appropriate data formats parse the test data into hierarchical structures instead of using it in its raw form. this is semantically cleaner and allows us to change the input format more easily.
2022-01-23 23:33:53 +00:00
return \%ss;
autotest: factor out readstate() from showstate() and ckstate()
2022-01-24 00:12:49 +00:00
}
autotest: support tests that don't modify the state file a test run may (legitimately or not) modify only the mailboxes, or even nothing at all. do something sensible in this case.
2022-01-26 20:56:50 +00:00
# \%fallback_sync_state
sub readchan(;$)
autotest: transform ck*() => cmp*() this avoids the ugly and error-prone repeated reading of the state after a failure. cmpbox() had to be made non-destructive on the box state. readchan() had to be created.
2022-02-06 14:43:53 +00:00
{
autotest: support tests that don't modify the state file a test run may (legitimately or not) modify only the mailboxes, or even nothing at all. do something sensible in this case.
2022-01-26 20:56:50 +00:00
my ($fbss) = @_;
autotest: transform ck*() => cmp*() this avoids the ugly and error-prone repeated reading of the state after a failure. cmpbox() had to be made non-destructive on the box state. readchan() had to be created.
2022-02-06 14:43:53 +00:00
return {
far => readbox("far"),
near => readbox("near"),
add autotest for message trashing
2022-04-04 16:55:14 +00:00
far_trash => readtrash("far_trash"),
near_trash => readtrash("near_trash"),
autotest: support tests that don't modify the state file a test run may (legitimately or not) modify only the mailboxes, or even nothing at all. do something sensible in this case.
2022-01-26 20:56:50 +00:00
state => readstate($fbss)
autotest: transform ck*() => cmp*() this avoids the ugly and error-prone repeated reading of the state after a failure. cmpbox() had to be made non-destructive on the box state. readchan() had to be created.
2022-02-06 14:43:53 +00:00
};
}
autotest: use more appropriate data formats parse the test data into hierarchical structures instead of using it in its raw form. this is semantically cleaner and allows us to change the input format more easily.
2022-01-23 23:33:53 +00:00
# $box_name, \%box_state
autotest: pass containers by reference this makes function prototypes a lot more useful for parameter checking.
2020-12-18 13:31:16 +00:00
sub mkbox($$)
add some regression testing.
2005-12-22 18:06:25 +00:00
{
autotest: pass containers by reference this makes function prototypes a lot more useful for parameter checking.
2020-12-18 13:31:16 +00:00
my ($bn, $bs) = @_;
add some regression testing.
2005-12-22 18:06:25 +00:00
rmtree($bn);
(mkdir($bn) and mkdir($bn."/tmp") and mkdir($bn."/new") and mkdir($bn."/cur")) or
die "Cannot create mailbox $bn.\n";
open(FILE, ">", $bn."/.uidvalidity") or die "Cannot create UID validity for mailbox $bn.\n";
autotest: use more appropriate data formats parse the test data into hierarchical structures instead of using it in its raw form. this is semantically cleaner and allows us to change the input format more easily.
2022-01-23 23:33:53 +00:00
print FILE "1\n$$bs{max_uid}\n";
add some regression testing.
2005-12-22 18:06:25 +00:00
close FILE;
autotest: use more appropriate data formats parse the test data into hierarchical structures instead of using it in its raw form. this is semantically cleaner and allows us to change the input format more easily.
2022-01-23 23:33:53 +00:00
my $ms = $$bs{messages};
for my $uid (keys %$ms) {
my ($num, $flg) = @{$$ms{$uid}};
add MaxSize tests
2005-12-26 16:01:42 +00:00
my $big = $flg =~ s/\*//;
create placeholders for messages over MaxSize this is vastly more useful than just omitting the messages with no indication at all.
2019-12-29 13:37:53 +00:00
my $ph = $flg =~ s/\?//;
autotest: assume that each message has a UID followup to 7ce658d14.
2020-04-03 09:21:09 +00:00
open(FILE, ">", $bn."/".($flg =~ /S/ ? "cur" : "new")."/0.1_".$num.".local,U=".$uid.":2,".$flg) or
autotest: use symbolic message subjects ... instead of numbers. otherwise there is too much confusion with UIDs.
2020-04-02 18:39:07 +00:00
die "Cannot create message ".mn($num)." in mailbox $bn.\n";
create placeholders for messages over MaxSize this is vastly more useful than just omitting the messages with no indication at all.
2019-12-29 13:37:53 +00:00
print FILE "From: foo\nTo: bar\nDate: Thu, 1 Jan 1970 00:00:00 +0000\nSubject: ".($ph?"[placeholder] ":"").$num."\n\n".(("A"x50)."\n")x($big*30);
add some regression testing.
2005-12-22 18:06:25 +00:00
close FILE;
}
}
autotest: use more appropriate data formats parse the test data into hierarchical structures instead of using it in its raw form. this is semantically cleaner and allows us to change the input format more easily.
2022-01-23 23:33:53 +00:00
# \%sync_state
autotest: factor out mkstate() for clarity and structural consistency.
2022-02-20 19:34:36 +00:00
sub mkstate($)
add some regression testing.
2005-12-22 18:06:25 +00:00
{
autotest: use more appropriate data formats parse the test data into hierarchical structures instead of using it in its raw form. this is semantically cleaner and allows us to change the input format more easily.
2022-01-23 23:33:53 +00:00
my ($ss) = @_;
autotest: let mkchan() take an atomic channel state this is consistent with ckchan() and printchan().
2022-01-23 22:19:41 +00:00
deprecate master/slave terminology the underlying metaphor refers to an inhumane practice, so using it casually is rightfully offensive to many people. it isn't even a particularly apt metaphor, as it suggests a strict hierarchy that is counter to mbsync's highly symmetrical mode of operation. the far/near terminology has been chosen as the replacement, as it is a natural fit for the push/pull terminology. on the downside, due to these not being nouns, a few uses are a bit awkward, and several others had to be amended to include 'side'. also, it's conceptually quite close to remote/local, which matches the typical use case, but is maybe a bit too suggestive of actually non-existing limitations. the new f/n suffixes of the -C/-R/-X options clash with pre-existing options, so direct concatenation of short options is even less practical than before (some suffixes of -D already clashed), but doing that leads to unreadable command lines anyway. as with previous deprecations, all pre-existing command line and config options keep working, but yield a warning. the state files are silently upgraded.
2020-07-22 17:44:26 +00:00
open(FILE, ">", "near/.mbsyncstate") or
add some regression testing.
2005-12-22 18:06:25 +00:00
die "Cannot create sync state.\n";
autotest: use more appropriate data formats parse the test data into hierarchical structures instead of using it in its raw form. this is semantically cleaner and allows us to change the input format more easily.
2022-01-23 23:33:53 +00:00
print FILE "FarUidValidity 1\nMaxPulledUid ".$$ss{max_pulled}."\n".
"NearUidValidity 1\nMaxExpiredFarUid ".$$ss{max_expired}.
"\nMaxPushedUid ".$$ss{max_pushed}."\n\n";
for my $ent (@{$$ss{entries}}) {
print FILE $$ent[0]." ".$$ent[1]." ".$$ent[2]."\n";
add some regression testing.
2005-12-22 18:06:25 +00:00
}
close FILE;
}
autotest: use more appropriate data formats parse the test data into hierarchical structures instead of using it in its raw form. this is semantically cleaner and allows us to change the input format more easily.
2022-01-23 23:33:53 +00:00
# \%chan_state
autotest: factor out mkstate() for clarity and structural consistency.
2022-02-20 19:34:36 +00:00
sub mkchan($)
{
my ($cs) = @_;
autotest: use more appropriate data formats parse the test data into hierarchical structures instead of using it in its raw form. this is semantically cleaner and allows us to change the input format more easily.
2022-01-23 23:33:53 +00:00
mkbox("far", $$cs{far});
mkbox("near", $$cs{near});
add autotest for message trashing
2022-04-04 16:55:14 +00:00
rmtree("far_trash");
rmtree("near_trash");
autotest: use more appropriate data formats parse the test data into hierarchical structures instead of using it in its raw form. this is semantically cleaner and allows us to change the input format more easily.
2022-01-23 23:33:53 +00:00
mkstate($$cs{state});
autotest: factor out mkstate() for clarity and structural consistency.
2022-02-20 19:34:36 +00:00
}
autotest: transform ck*() => cmp*() this avoids the ugly and error-prone repeated reading of the state after a failure. cmpbox() had to be made non-destructive on the box state. readchan() had to be created.
2022-02-06 14:43:53 +00:00
# $box_name, \%actual_box_state, \%reference_box_state
sub cmpbox($$$)
add some regression testing.
2005-12-22 18:06:25 +00:00
{
autotest: transform ck*() => cmp*() this avoids the ugly and error-prone repeated reading of the state after a failure. cmpbox() had to be made non-destructive on the box state. readchan() had to be created.
2022-02-06 14:43:53 +00:00
my ($bn, $bs, $ref_bs) = @_;
add some regression testing.
2005-12-22 18:06:25 +00:00
autotest: make state comparison more elaborate don't abort the comparison if continuing makes sense, and try to be more specific about the problems. we give up if messages are excessive/missing or the subject is wrong, as that touches upon the rather complex problem of diff optimization.
2022-01-27 13:22:29 +00:00
my $ret = 0;
autotest: use more appropriate data formats parse the test data into hierarchical structures instead of using it in its raw form. this is semantically cleaner and allows us to change the input format more easily.
2022-01-23 23:33:53 +00:00
my ($ref_mu, $ref_ms) = ($$ref_bs{max_uid}, $$ref_bs{messages});
my ($mu, $ms) = ($$bs{max_uid}, $$bs{messages});
if ($mu != $ref_mu) {
autotest: make state comparison more elaborate don't abort the comparison if continuing makes sense, and try to be more specific about the problems. we give up if messages are excessive/missing or the subject is wrong, as that touches upon the rather complex problem of diff optimization.
2022-01-27 13:22:29 +00:00
print STDERR "MAXUID mismatch for '$bn': got $mu, wanted $ref_mu\n";
$ret = 1;
add some regression testing.
2005-12-22 18:06:25 +00:00
}
autotest: use more appropriate data formats parse the test data into hierarchical structures instead of using it in its raw form. this is semantically cleaner and allows us to change the input format more easily.
2022-01-23 23:33:53 +00:00
for my $uid (sort { $a <=> $b } keys %$ref_ms) {
my ($num, $flg) = @{$$ref_ms{$uid}};
autotest: transform ck*() => cmp*() this avoids the ugly and error-prone repeated reading of the state after a failure. cmpbox() had to be made non-destructive on the box state. readchan() had to be created.
2022-02-06 14:43:53 +00:00
my $m = $$ms{$uid};
autotest: re-organize mailbox storage by UID an effect of 7ce658d is that we can index messages by UID rather than content (or more specifically, subject). apart from being cleaner, it allows duplicated subjects.
2020-04-03 10:18:26 +00:00
if (!defined $m) {
autotest: make state comparison more elaborate don't abort the comparison if continuing makes sense, and try to be more specific about the problems. we give up if messages are excessive/missing or the subject is wrong, as that touches upon the rather complex problem of diff optimization.
2022-01-27 13:22:29 +00:00
print STDERR "Missing message $bn:$uid:".mn($num)."\n";
$ret = 1;
next;
add some regression testing.
2005-12-22 18:06:25 +00:00
}
autotest: use ints where we mean ints ... instead of using strings. perl allows being sloppy, but it doesn't really help understanding the code.
2022-01-24 20:49:18 +00:00
if ($$m[0] != $num) {
autotest: make state comparison more elaborate don't abort the comparison if continuing makes sense, and try to be more specific about the problems. we give up if messages are excessive/missing or the subject is wrong, as that touches upon the rather complex problem of diff optimization.
2022-01-27 13:22:29 +00:00
print STDERR "Subject mismatch for $bn:$uid:".
" got ".mn($$m[0]).", wanted ".mn($num)."\n";
make the error case output more useful by dumping the entire data set.
2005-12-27 17:31:04 +00:00
return 1;
add some regression testing.
2005-12-22 18:06:25 +00:00
}
autotest: re-organize mailbox storage by UID an effect of 7ce658d is that we can index messages by UID rather than content (or more specifically, subject). apart from being cleaner, it allows duplicated subjects.
2020-04-03 10:18:26 +00:00
if ($$m[1] ne $flg) {
autotest: make state comparison more elaborate don't abort the comparison if continuing makes sense, and try to be more specific about the problems. we give up if messages are excessive/missing or the subject is wrong, as that touches upon the rather complex problem of diff optimization.
2022-01-27 13:22:29 +00:00
print STDERR "Flag mismatch for $bn:$uid:".mn($num).":".
" got ".mf($$m[1]).", wanted ".mf($flg)."\n";
$ret = 1;
add some regression testing.
2005-12-22 18:06:25 +00:00
}
detect excess messages after sync
2005-12-26 15:58:12 +00:00
}
autotest: transform ck*() => cmp*() this avoids the ugly and error-prone repeated reading of the state after a failure. cmpbox() had to be made non-destructive on the box state. readchan() had to be created.
2022-02-06 14:43:53 +00:00
for my $uid (sort { $a <=> $b } keys %$ms) {
if (!defined($$ref_ms{$uid})) {
print STDERR "Excess message $bn:$uid:".mn($$ms{$uid}[0])."\n";
autotest: make state comparison more elaborate don't abort the comparison if continuing makes sense, and try to be more specific about the problems. we give up if messages are excessive/missing or the subject is wrong, as that touches upon the rather complex problem of diff optimization.
2022-01-27 13:22:29 +00:00
$ret = 1;
}
}
return $ret;
}
add autotest for message trashing
2022-04-04 16:55:14 +00:00
# $box_name, \%actual_box_state, \%reference_box_state
sub cmptrash($$$)
{
my ($bn, $ms, $ref_ms) = @_;
my $ret = 0;
for my $num (sort { $a <=> $b } keys %$ref_ms) {
my $ph = $$ms{$num};
if (!defined($ph)) {
print STDERR "Missing message $bn:".mn($num)."\n";
$ret = 1;
}
exclude placeholders from trashing it makes no sense to trash the placeholders, and in fact the common case is that they are deleted due to being replaced by the full message. a separate S_PURGED state needed to be added, as S_PURGE needs to be reset after setting F_DELETED (so the operation doesn't count as still pending after journal replay), yet trashing needs an indicator. logging is now done via a separate command, as piggy-backing it on flag updates just makes things less legible for no benefit. this is mostly academical, as trashing being done on the side where placeholders reside is rather unlikely.
2022-04-04 19:41:18 +00:00
if ($ph) {
print STDERR "Message $bn:".mn($num)." is placeholder\n";
$ret = 1;
}
add autotest for message trashing
2022-04-04 16:55:14 +00:00
}
for my $num (sort { $a <=> $b } keys %$ms) {
if (!defined($$ref_ms{$num})) {
exclude placeholders from trashing it makes no sense to trash the placeholders, and in fact the common case is that they are deleted due to being replaced by the full message. a separate S_PURGED state needed to be added, as S_PURGE needs to be reset after setting F_DELETED (so the operation doesn't count as still pending after journal replay), yet trashing needs an indicator. logging is now done via a separate command, as piggy-backing it on flag updates just makes things less legible for no benefit. this is mostly academical, as trashing being done on the side where placeholders reside is rather unlikely.
2022-04-04 19:41:18 +00:00
print STDERR "Excess message $bn:".mn($num).($$ms{$num} ? " (is placeholder)" : "")."\n";
add autotest for message trashing
2022-04-04 16:55:14 +00:00
$ret = 1;
}
}
return $ret;
}
autotest: make state comparison more elaborate don't abort the comparison if continuing makes sense, and try to be more specific about the problems. we give up if messages are excessive/missing or the subject is wrong, as that touches upon the rather complex problem of diff optimization.
2022-01-27 13:22:29 +00:00
sub mapmsg($$)
{
my ($uid, $bs) = @_;
if ($uid) {
if (my $msg = $$bs{messages}{$uid}) {
return $$msg[0];
autotest: transform ck*() => cmp*() this avoids the ugly and error-prone repeated reading of the state after a failure. cmpbox() had to be made non-destructive on the box state. readchan() had to be created.
2022-02-06 14:43:53 +00:00
}
add some regression testing.
2005-12-22 18:06:25 +00:00
}
make the error case output more useful by dumping the entire data set.
2005-12-27 17:31:04 +00:00
return 0;
add some regression testing.
2005-12-22 18:06:25 +00:00
}
autotest: make state comparison more elaborate don't abort the comparison if continuing makes sense, and try to be more specific about the problems. we give up if messages are excessive/missing or the subject is wrong, as that touches upon the rather complex problem of diff optimization.
2022-01-27 13:22:29 +00:00
# \%actual_chan_state, \%reference_chan_state
autotest: transform ck*() => cmp*() this avoids the ugly and error-prone repeated reading of the state after a failure. cmpbox() had to be made non-destructive on the box state. readchan() had to be created.
2022-02-06 14:43:53 +00:00
sub cmpstate($$)
add some regression testing.
2005-12-22 18:06:25 +00:00
{
autotest: make state comparison more elaborate don't abort the comparison if continuing makes sense, and try to be more specific about the problems. we give up if messages are excessive/missing or the subject is wrong, as that touches upon the rather complex problem of diff optimization.
2022-01-27 13:22:29 +00:00
my ($cs, $ref_cs) = @_;
autotest: factor out readstate() from showstate() and ckstate()
2022-01-24 00:12:49 +00:00
autotest: make state comparison more elaborate don't abort the comparison if continuing makes sense, and try to be more specific about the problems. we give up if messages are excessive/missing or the subject is wrong, as that touches upon the rather complex problem of diff optimization.
2022-01-27 13:22:29 +00:00
my ($ss, $fbs, $nbs) = ($$cs{state}, $$cs{far}, $$cs{near});
autotest: factor out readstate() from showstate() and ckstate()
2022-01-24 00:12:49 +00:00
return 1 if (!$ss);
autotest: make state comparison more elaborate don't abort the comparison if continuing makes sense, and try to be more specific about the problems. we give up if messages are excessive/missing or the subject is wrong, as that touches upon the rather complex problem of diff optimization.
2022-01-27 13:22:29 +00:00
my ($ref_ss, $ref_fbs, $ref_nbs) = ($$ref_cs{state}, $$ref_cs{far}, $$ref_cs{near});
autotest: support tests that don't modify the state file a test run may (legitimately or not) modify only the mailboxes, or even nothing at all. do something sensible in this case.
2022-01-26 20:56:50 +00:00
return 0 if ($ss == $ref_ss);
autotest: make state comparison more elaborate don't abort the comparison if continuing makes sense, and try to be more specific about the problems. we give up if messages are excessive/missing or the subject is wrong, as that touches upon the rather complex problem of diff optimization.
2022-01-27 13:22:29 +00:00
my $ret = 0;
autotest: use more appropriate data formats parse the test data into hierarchical structures instead of using it in its raw form. this is semantically cleaner and allows us to change the input format more easily.
2022-01-23 23:33:53 +00:00
for my $h (['MaxPulledUid', 'max_pulled'],
['MaxExpiredFarUid', 'max_expired'],
['MaxPushedUid', 'max_pushed']) {
my ($hn, $sn) = @$h;
my ($got, $want) = ($$ss{$sn}, $$ref_ss{$sn});
autotest: use ints where we mean ints ... instead of using strings. perl allows being sloppy, but it doesn't really help understanding the code.
2022-01-24 20:49:18 +00:00
if ($got != $want) {
autotest: use more appropriate data formats parse the test data into hierarchical structures instead of using it in its raw form. this is semantically cleaner and allows us to change the input format more easily.
2022-01-23 23:33:53 +00:00
print STDERR "Sync state header entry $hn mismatch: got $got, wanted $want\n";
autotest: make state comparison more elaborate don't abort the comparison if continuing makes sense, and try to be more specific about the problems. we give up if messages are excessive/missing or the subject is wrong, as that touches upon the rather complex problem of diff optimization.
2022-01-27 13:22:29 +00:00
$ret = 1;
add some regression testing.
2005-12-22 18:06:25 +00:00
}
make sync state header format less obscure the header is not space-critical, so use proper name-value pairs. this has the additional advantage that subsequent format changes can be done much easier.
2013-11-16 12:25:31 +00:00
}
autotest: use more appropriate data formats parse the test data into hierarchical structures instead of using it in its raw form. this is semantically cleaner and allows us to change the input format more easily.
2022-01-23 23:33:53 +00:00
my $ref_ents = $$ref_ss{entries};
my $ents = $$ss{entries};
autotest: make state comparison more elaborate don't abort the comparison if continuing makes sense, and try to be more specific about the problems. we give up if messages are excessive/missing or the subject is wrong, as that touches upon the rather complex problem of diff optimization.
2022-01-27 13:22:29 +00:00
for (my $i = 0; $i < @$ents || $i < @$ref_ents; $i++) {
my ($ent, $fuid, $nuid, $num);
if ($i < @$ents) {
$ent = $$ents[$i];
($fuid, $nuid) = ($$ent[0], $$ent[1]);
my ($fnum, $nnum) = (mapmsg($fuid, $fbs), mapmsg($nuid, $nbs));
if ($fnum && $nnum && $fnum != $nnum) {
print STDERR "Invalid sync state entry $fuid:$nuid:".
" mismatched subjects (".mn($fnum).":".mn($nnum).")\n";
return 1;
}
$num = $fnum || $nnum;
}
autotest: use more appropriate data formats parse the test data into hierarchical structures instead of using it in its raw form. this is semantically cleaner and allows us to change the input format more easily.
2022-01-23 23:33:53 +00:00
if ($i == @$ref_ents) {
autotest: make state comparison more elaborate don't abort the comparison if continuing makes sense, and try to be more specific about the problems. we give up if messages are excessive/missing or the subject is wrong, as that touches upon the rather complex problem of diff optimization.
2022-01-27 13:22:29 +00:00
print STDERR "Excess sync state entry $fuid:$nuid (".mn($num).")\n";
more precise failure reporting
2013-11-16 12:41:27 +00:00
return 1;
}
autotest: use more appropriate data formats parse the test data into hierarchical structures instead of using it in its raw form. this is semantically cleaner and allows us to change the input format more easily.
2022-01-23 23:33:53 +00:00
my $rent = $$ref_ents[$i];
autotest: make state comparison more elaborate don't abort the comparison if continuing makes sense, and try to be more specific about the problems. we give up if messages are excessive/missing or the subject is wrong, as that touches upon the rather complex problem of diff optimization.
2022-01-27 13:22:29 +00:00
my ($rfuid, $rnuid) = ($$rent[0], $$rent[1]);
my $rnum = mapmsg($rfuid, $ref_fbs) || mapmsg($rnuid, $ref_nbs);
if ($i == @$ents) {
print STDERR "Missing sync state entry $rfuid:$rnuid (".mn($rnum).")\n";
make sync state header format less obscure the header is not space-critical, so use proper name-value pairs. this has the additional advantage that subsequent format changes can be done much easier.
2013-11-16 12:25:31 +00:00
return 1;
}
autotest: make state comparison more elaborate don't abort the comparison if continuing makes sense, and try to be more specific about the problems. we give up if messages are excessive/missing or the subject is wrong, as that touches upon the rather complex problem of diff optimization.
2022-01-27 13:22:29 +00:00
if ($fuid != $rfuid || $nuid != $rnuid || $num != $rnum) {
print STDERR "Unexpected sync state entry:".
" got $fuid:$nuid (".mn($num)."), wanted $rfuid:$rnuid (".mn($rnum).")\n";
return 1;
}
if ($$ent[2] ne $$rent[2]) {
print STDERR "Flag mismatch in sync state entry $fuid:$nuid (".mn($rnum)."):".
" got ".mf($$ent[2]).", wanted ".mf($$rent[2])."\n";
$ret = 1;
}
add some regression testing.
2005-12-22 18:06:25 +00:00
}
autotest: make state comparison more elaborate don't abort the comparison if continuing makes sense, and try to be more specific about the problems. we give up if messages are excessive/missing or the subject is wrong, as that touches upon the rather complex problem of diff optimization.
2022-01-27 13:22:29 +00:00
return $ret;
much improved journal replay testing. some clenup.
2006-02-02 10:25:07 +00:00
}
autotest: transform ck*() => cmp*() this avoids the ugly and error-prone repeated reading of the state after a failure. cmpbox() had to be made non-destructive on the box state. readchan() had to be created.
2022-02-06 14:43:53 +00:00
# \%actual_chan_state, \%reference_chan_state
sub cmpchan($$)
much improved journal replay testing. some clenup.
2006-02-02 10:25:07 +00:00
{
autotest: transform ck*() => cmp*() this avoids the ugly and error-prone repeated reading of the state after a failure. cmpbox() had to be made non-destructive on the box state. readchan() had to be created.
2022-02-06 14:43:53 +00:00
my ($cs, $ref_cs) = @_;
my $rslt = 0;
$rslt |= cmpbox("far", $$cs{far}, $$ref_cs{far});
$rslt |= cmpbox("near", $$cs{near}, $$ref_cs{near});
add autotest for message trashing
2022-04-04 16:55:14 +00:00
$rslt |= cmptrash("far_trash", $$cs{far_trash}, $$ref_cs{far_trash});
$rslt |= cmptrash("near_trash", $$cs{near_trash}, $$ref_cs{near_trash});
autotest: make state comparison more elaborate don't abort the comparison if continuing makes sense, and try to be more specific about the problems. we give up if messages are excessive/missing or the subject is wrong, as that touches upon the rather complex problem of diff optimization.
2022-01-27 13:22:29 +00:00
$rslt |= cmpstate($cs, $ref_cs);
make the error case output more useful by dumping the entire data set.
2005-12-27 17:31:04 +00:00
return $rslt;
add some regression testing.
2005-12-22 18:06:25 +00:00
}
autotest: use more appropriate data formats parse the test data into hierarchical structures instead of using it in its raw form. this is semantically cleaner and allows us to change the input format more easily.
2022-01-23 23:33:53 +00:00
# \%box_state
autotest: remove unused boxname parameter from printbox()
2020-12-18 13:33:26 +00:00
sub printbox($)
add some regression testing.
2005-12-22 18:06:25 +00:00
{
autotest: remove unused boxname parameter from printbox()
2020-12-18 13:33:26 +00:00
my ($bs) = @_;
add some regression testing.
2005-12-22 18:06:25 +00:00
autotest: use more appropriate data formats parse the test data into hierarchical structures instead of using it in its raw form. this is semantically cleaner and allows us to change the input format more easily.
2022-01-23 23:33:53 +00:00
my ($mu, $ms) = ($$bs{max_uid}, $$bs{messages});
print " [ $mu,\n ";
add some regression testing.
2005-12-22 18:06:25 +00:00
my $frst = 1;
autotest: use more appropriate data formats parse the test data into hierarchical structures instead of using it in its raw form. this is semantically cleaner and allows us to change the input format more easily.
2022-01-23 23:33:53 +00:00
for my $uid (sort { $a <=> $b } keys %$ms) {
my ($num, $flg) = @{$$ms{$uid}};
add some regression testing.
2005-12-22 18:06:25 +00:00
if ($frst) {
$frst = 0;
} else {
print ", ";
}
autotest: use more appropriate data formats parse the test data into hierarchical structures instead of using it in its raw form. this is semantically cleaner and allows us to change the input format more easily.
2022-01-23 23:33:53 +00:00
print mn($num).", ".$uid.", \"".$flg."\"";
add some regression testing.
2005-12-22 18:06:25 +00:00
}
print " ],\n";
}
autotest: use more appropriate data formats parse the test data into hierarchical structures instead of using it in its raw form. this is semantically cleaner and allows us to change the input format more easily.
2022-01-23 23:33:53 +00:00
# \%sync_state
autotest: pass containers by reference this makes function prototypes a lot more useful for parameter checking.
2020-12-18 13:31:16 +00:00
sub printstate($)
add some regression testing.
2005-12-22 18:06:25 +00:00
{
autotest: use more appropriate data formats parse the test data into hierarchical structures instead of using it in its raw form. this is semantically cleaner and allows us to change the input format more easily.
2022-01-23 23:33:53 +00:00
my ($ss) = @_;
make the error case output more useful by dumping the entire data set.
2005-12-27 17:31:04 +00:00
autotest: transform ck*() => cmp*() this avoids the ugly and error-prone repeated reading of the state after a failure. cmpbox() had to be made non-destructive on the box state. readchan() had to be created.
2022-02-06 14:43:53 +00:00
return if (!$ss);
autotest: use more appropriate data formats parse the test data into hierarchical structures instead of using it in its raw form. this is semantically cleaner and allows us to change the input format more easily.
2022-01-23 23:33:53 +00:00
print " [ ".$$ss{max_pulled}.", ".$$ss{max_expired}.", ".$$ss{max_pushed}.",\n ";
add some regression testing.
2005-12-22 18:06:25 +00:00
my $frst = 1;
autotest: use more appropriate data formats parse the test data into hierarchical structures instead of using it in its raw form. this is semantically cleaner and allows us to change the input format more easily.
2022-01-23 23:33:53 +00:00
for my $ent (@{$$ss{entries}}) {
add some regression testing.
2005-12-22 18:06:25 +00:00
if ($frst) {
$frst = 0;
} else {
print ", ";
}
autotest: use more appropriate data formats parse the test data into hierarchical structures instead of using it in its raw form. this is semantically cleaner and allows us to change the input format more easily.
2022-01-23 23:33:53 +00:00
print(($$ent[0] // "??").", ".($$ent[1] // "??").", \"".($$ent[2] // "??")."\"");
add some regression testing.
2005-12-22 18:06:25 +00:00
}
print " ],\n";
}
autotest: use more appropriate data formats parse the test data into hierarchical structures instead of using it in its raw form. this is semantically cleaner and allows us to change the input format more easily.
2022-01-23 23:33:53 +00:00
# \%chan_state
take configs out of target state defs cleaner and less duplication
2013-11-09 12:06:39 +00:00
sub printchan($)
much improved journal replay testing. some clenup.
2006-02-02 10:25:07 +00:00
{
take configs out of target state defs cleaner and less duplication
2013-11-09 12:06:39 +00:00
my ($cs) = @_;
much improved journal replay testing. some clenup.
2006-02-02 10:25:07 +00:00
autotest: use more appropriate data formats parse the test data into hierarchical structures instead of using it in its raw form. this is semantically cleaner and allows us to change the input format more easily.
2022-01-23 23:33:53 +00:00
printbox($$cs{far});
printbox($$cs{near});
printstate($$cs{state});
much improved journal replay testing. some clenup.
2006-02-02 10:25:07 +00:00
}
autotest: use more appropriate data formats parse the test data into hierarchical structures instead of using it in its raw form. this is semantically cleaner and allows us to change the input format more easily.
2022-01-23 23:33:53 +00:00
# $run_async, \%source_state, \%target_state, \@channel_configs
autotest: pass containers by reference this makes function prototypes a lot more useful for parameter checking.
2020-12-18 13:31:16 +00:00
sub test_impl($$$$)
add some regression testing.
2005-12-22 18:06:25 +00:00
{
autotest: pass containers by reference this makes function prototypes a lot more useful for parameter checking.
2020-12-18 13:31:16 +00:00
my ($async, $sx, $tx, $sfx) = @_;
verify idempotence of all sync operations
2013-11-04 08:54:39 +00:00
autotest: let mkchan() take an atomic channel state this is consistent with ckchan() and printchan().
2022-01-23 22:19:41 +00:00
mkchan($sx);
autotest: implement much more thorough resumption verification the test will now make a test run for every journaled step, both right before and right after the logging.
2017-03-19 10:53:16 +00:00
autotest skipping doomed messages more thoroughly ensure that the messages are actually skipped, not subsequently expunged.
2022-03-17 11:58:05 +00:00
my ($xopt, $xsopt) = @$sfx > 3 ? ($$sfx[3], " ".$$sfx[3]) : ("", "");
my ($xc, $ret) = runsync($async, "-Tj -TJ".$xsopt, "1-initial.log");
autotest: support tests that don't modify the state file a test run may (legitimately or not) modify only the mailboxes, or even nothing at all. do something sensible in this case.
2022-01-26 20:56:50 +00:00
my $rtx = readchan($$sx{state}) if (!$xc);
autotest: transform ck*() => cmp*() this avoids the ugly and error-prone repeated reading of the state after a failure. cmpbox() had to be made non-destructive on the box state. readchan() had to be created.
2022-02-06 14:43:53 +00:00
if ($xc || cmpchan($rtx, $tx)) {
handle abnormal program exit during regtest
2006-12-09 10:38:11 +00:00
print "Input:\n";
take configs out of target state defs cleaner and less duplication
2013-11-09 12:06:39 +00:00
printchan($sx);
handle abnormal program exit during regtest
2006-12-09 10:38:11 +00:00
print "Options:\n";
autotest: pass containers by reference this makes function prototypes a lot more useful for parameter checking.
2020-12-18 13:31:16 +00:00
print " [ ".join(", ", map('"'.qm($_).'"', @$sfx))." ]\n";
autotest: de-duplicate error reporting paths
2017-03-14 13:52:22 +00:00
if (!$xc) {
print "Expected result:\n";
printchan($tx);
print "Actual result:\n";
autotest: transform ck*() => cmp*() this avoids the ugly and error-prone repeated reading of the state after a failure. cmpbox() had to be made non-destructive on the box state. readchan() had to be created.
2022-02-06 14:43:53 +00:00
printchan($rtx);
autotest: de-duplicate error reporting paths
2017-03-14 13:52:22 +00:00
}
much improved journal replay testing. some clenup.
2006-02-02 10:25:07 +00:00
print "Debug output:\n";
autotest: pass containers by reference this makes function prototypes a lot more useful for parameter checking.
2020-12-18 13:31:16 +00:00
print @$ret;
much improved journal replay testing. some clenup.
2006-02-02 10:25:07 +00:00
exit 1;
}
verify idempotence of all sync operations
2013-11-04 08:54:39 +00:00
rework interrupt-resume autotesting instead of doing two runs for each journal entry, do one run for each "write" operation, be it a journal entry or a writing driver call. this saves runs between which no visible change occurred, which yields a 33% improvement in runtime. we now also exclude the final entry purge from the test, as it's really kinda pointless, and we'd have to jump through additional hoops (simulate an atomic commit of the state) to make it reliable in all cases. note that this also adds a few steps, which actually uncovered a bug in the expunge sequencing. amends efd72b85.
2022-03-01 14:16:07 +00:00
my ($nj, $njl, $nje) = (undef, 0, 0);
autotest: support tests that don't modify the state file a test run may (legitimately or not) modify only the mailboxes, or even nothing at all. do something sensible in this case.
2022-01-26 20:56:50 +00:00
if ($$rtx{state} != $$sx{state}) {
$nj = readfile("near/.mbsyncstate.journal");
rework interrupt-resume autotesting instead of doing two runs for each journal entry, do one run for each "write" operation, be it a journal entry or a writing driver call. this saves runs between which no visible change occurred, which yields a 33% improvement in runtime. we now also exclude the final entry purge from the test, as it's really kinda pointless, and we'd have to jump through additional hoops (simulate an atomic commit of the state) to make it reliable in all cases. note that this also adds a few steps, which actually uncovered a bug in the expunge sequencing. amends efd72b85.
2022-03-01 14:16:07 +00:00
STEPS: {
for (reverse @$ret) {
if (/^### (\d+) steps, (\d+) entries ###$/) {
$njl = int($1) - 1;
$nje = int($2);
last STEPS;
}
}
die("Cannot extract step count.\n");
}
autotest: support tests that don't modify the state file a test run may (legitimately or not) modify only the mailboxes, or even nothing at all. do something sensible in this case.
2022-01-26 20:56:50 +00:00
autotest skipping doomed messages more thoroughly ensure that the messages are actually skipped, not subsequently expunged.
2022-03-17 11:58:05 +00:00
my ($jxc, $jret) = runsync($async, "-0 --no-expunge".$xsopt, "2-replay.log");
autotest: support tests that don't modify the state file a test run may (legitimately or not) modify only the mailboxes, or even nothing at all. do something sensible in this case.
2022-01-26 20:56:50 +00:00
my $jrcs = readstate() if (!$jxc);
autotest: make state comparison more elaborate don't abort the comparison if continuing makes sense, and try to be more specific about the problems. we give up if messages are excessive/missing or the subject is wrong, as that touches upon the rather complex problem of diff optimization.
2022-01-27 13:22:29 +00:00
if ($jxc || cmpstate({ far => $$tx{far}, near => $$tx{near}, state => $jrcs }, $tx)) {
autotest: support tests that don't modify the state file a test run may (legitimately or not) modify only the mailboxes, or even nothing at all. do something sensible in this case.
2022-01-26 20:56:50 +00:00
print "Journal replay failed.\n";
print "Options:\n";
print " [ ".join(", ", map('"'.qm($_).'"', @$sfx))." ], [ \"-0\", \"--no-expunge\" ]\n";
print "Old State:\n";
printstate($$sx{state});
print "Journal:\n".join("", @$nj)."\n";
if (!$jxc) {
print "Expected New State:\n";
printstate($$tx{state});
print "New State:\n";
printstate($jrcs);
}
print "Debug output:\n";
print @$jret;
exit 1;
autotest: de-duplicate error reporting paths
2017-03-14 13:52:22 +00:00
}
make the error case output more useful by dumping the entire data set.
2005-12-27 17:31:04 +00:00
}
verify idempotence of all sync operations
2013-11-04 08:54:39 +00:00
autotest skipping doomed messages more thoroughly ensure that the messages are actually skipped, not subsequently expunged.
2022-03-17 11:58:05 +00:00
my ($ixc, $iret) = runsync($async, $xopt, "3-verify.log");
autotest: support tests that don't modify the state file a test run may (legitimately or not) modify only the mailboxes, or even nothing at all. do something sensible in this case.
2022-01-26 20:56:50 +00:00
my $irtx = readchan() if (!$ixc);
autotest: transform ck*() => cmp*() this avoids the ugly and error-prone repeated reading of the state after a failure. cmpbox() had to be made non-destructive on the box state. readchan() had to be created.
2022-02-06 14:43:53 +00:00
if ($ixc || cmpchan($irtx, $tx)) {
verify idempotence of all sync operations
2013-11-04 08:54:39 +00:00
print "Idempotence verification run failed.\n";
print "Input == Expected result:\n";
printchan($tx);
print "Options:\n";
autotest: pass containers by reference this makes function prototypes a lot more useful for parameter checking.
2020-12-18 13:31:16 +00:00
print " [ ".join(", ", map('"'.qm($_).'"', @$sfx))." ]\n";
autotest: implement much more thorough resumption verification the test will now make a test run for every journaled step, both right before and right after the logging.
2017-03-19 10:53:16 +00:00
if (!$ixc) {
autotest: de-duplicate error reporting paths
2017-03-14 13:52:22 +00:00
print "Actual result:\n";
autotest: transform ck*() => cmp*() this avoids the ugly and error-prone repeated reading of the state after a failure. cmpbox() had to be made non-destructive on the box state. readchan() had to be created.
2022-02-06 14:43:53 +00:00
printchan($irtx);
autotest: de-duplicate error reporting paths
2017-03-14 13:52:22 +00:00
}
verify idempotence of all sync operations
2013-11-04 08:54:39 +00:00
print "Debug output:\n";
autotest: pass containers by reference this makes function prototypes a lot more useful for parameter checking.
2020-12-18 13:31:16 +00:00
print @$iret;
verify idempotence of all sync operations
2013-11-04 08:54:39 +00:00
exit 1;
}
deprecate master/slave terminology the underlying metaphor refers to an inhumane practice, so using it casually is rightfully offensive to many people. it isn't even a particularly apt metaphor, as it suggests a strict hierarchy that is counter to mbsync's highly symmetrical mode of operation. the far/near terminology has been chosen as the replacement, as it is a natural fit for the push/pull terminology. on the downside, due to these not being nouns, a few uses are a bit awkward, and several others had to be amended to include 'side'. also, it's conceptually quite close to remote/local, which matches the typical use case, but is maybe a bit too suggestive of actually non-existing limitations. the new f/n suffixes of the -C/-R/-X options clash with pre-existing options, so direct concatenation of short options is even less practical than before (some suffixes of -D already clashed), but doing that leads to unreadable command lines anyway. as with previous deprecations, all pre-existing command line and config options keep working, but yield a warning. the state files are silently upgraded.
2020-07-22 17:44:26 +00:00
rmtree "near";
rmtree "far";
add autotest for message trashing
2022-04-04 16:55:14 +00:00
rmtree "near_trash";
rmtree "far_trash";
autotest: implement much more thorough resumption verification the test will now make a test run for every journaled step, both right before and right after the logging.
2017-03-19 10:53:16 +00:00
don't rewrite state gratuitously delay the creation of the new state and journal until there is actually something interesting to write. this saves some cpu cycles and prolongs ssd life a whee bit.
2019-11-25 19:55:41 +00:00
for (my $l = 1; $l <= $njl; $l++) {
autotest: let mkchan() take an atomic channel state this is consistent with ckchan() and printchan().
2022-01-23 22:19:41 +00:00
mkchan($sx);
autotest: implement much more thorough resumption verification the test will now make a test run for every journaled step, both right before and right after the logging.
2017-03-19 10:53:16 +00:00
autotest skipping doomed messages more thoroughly ensure that the messages are actually skipped, not subsequently expunged.
2022-03-17 11:58:05 +00:00
my ($nxc, $nret) = runsync($async, "-Ts$l".$xsopt, "4-interrupt.log");
rework interrupt-resume autotesting instead of doing two runs for each journal entry, do one run for each "write" operation, be it a journal entry or a writing driver call. this saves runs between which no visible change occurred, which yields a 33% improvement in runtime. we now also exclude the final entry purge from the test, as it's really kinda pointless, and we'd have to jump through additional hoops (simulate an atomic commit of the state) to make it reliable in all cases. note that this also adds a few steps, which actually uncovered a bug in the expunge sequencing. amends efd72b85.
2022-03-01 14:16:07 +00:00
if ($nxc != 100 << 8) {
autotest: implement much more thorough resumption verification the test will now make a test run for every journaled step, both right before and right after the logging.
2017-03-19 10:53:16 +00:00
print "Interrupting at step $l/$njl failed.\n";
print "Debug output:\n";
autotest: pass containers by reference this makes function prototypes a lot more useful for parameter checking.
2020-12-18 13:31:16 +00:00
print @$nret;
autotest: implement much more thorough resumption verification the test will now make a test run for every journaled step, both right before and right after the logging.
2017-03-19 10:53:16 +00:00
exit 1;
}
rework interrupt-resume autotesting instead of doing two runs for each journal entry, do one run for each "write" operation, be it a journal entry or a writing driver call. this saves runs between which no visible change occurred, which yields a 33% improvement in runtime. we now also exclude the final entry purge from the test, as it's really kinda pointless, and we'd have to jump through additional hoops (simulate an atomic commit of the state) to make it reliable in all cases. note that this also adds a few steps, which actually uncovered a bug in the expunge sequencing. amends efd72b85.
2022-03-01 14:16:07 +00:00
my $pnnj = readfile("near/.mbsyncstate.journal");
autotest skipping doomed messages more thoroughly ensure that the messages are actually skipped, not subsequently expunged.
2022-03-17 11:58:05 +00:00
($nxc, $nret) = runsync($async, "-Tj".$xsopt, "5-resume.log");
autotest: support tests that don't modify the state file a test run may (legitimately or not) modify only the mailboxes, or even nothing at all. do something sensible in this case.
2022-01-26 20:56:50 +00:00
my $nrtx = readchan($$sx{state}) if (!$nxc);
autotest: transform ck*() => cmp*() this avoids the ugly and error-prone repeated reading of the state after a failure. cmpbox() had to be made non-destructive on the box state. readchan() had to be created.
2022-02-06 14:43:53 +00:00
if ($nxc || cmpchan($nrtx, $tx)) {
autotest: implement much more thorough resumption verification the test will now make a test run for every journaled step, both right before and right after the logging.
2017-03-19 10:53:16 +00:00
print "Resuming from step $l/$njl failed.\n";
print "Input:\n";
printchan($sx);
print "Options:\n";
autotest: pass containers by reference this makes function prototypes a lot more useful for parameter checking.
2020-12-18 13:31:16 +00:00
print " [ ".join(", ", map('"'.qm($_).'"', @$sfx))." ]\n";
my $nnj = readfile("near/.mbsyncstate.journal");
rework interrupt-resume autotesting instead of doing two runs for each journal entry, do one run for each "write" operation, be it a journal entry or a writing driver call. this saves runs between which no visible change occurred, which yields a 33% improvement in runtime. we now also exclude the final entry purge from the test, as it's really kinda pointless, and we'd have to jump through additional hoops (simulate an atomic commit of the state) to make it reliable in all cases. note that this also adds a few steps, which actually uncovered a bug in the expunge sequencing. amends efd72b85.
2022-03-01 14:16:07 +00:00
my $ln = $#$pnnj;
autotest: pass containers by reference this makes function prototypes a lot more useful for parameter checking.
2020-12-18 13:31:16 +00:00
print "Journal:\n".join("", @$nnj[0..$ln])."-------\n".join("", @$nnj[($ln + 1)..$#$nnj])."\n";
rework interrupt-resume autotesting instead of doing two runs for each journal entry, do one run for each "write" operation, be it a journal entry or a writing driver call. this saves runs between which no visible change occurred, which yields a 33% improvement in runtime. we now also exclude the final entry purge from the test, as it's really kinda pointless, and we'd have to jump through additional hoops (simulate an atomic commit of the state) to make it reliable in all cases. note that this also adds a few steps, which actually uncovered a bug in the expunge sequencing. amends efd72b85.
2022-03-01 14:16:07 +00:00
print "Full journal:\n".join("", @$nj[0..$nje])."=======\n".join("", @$nj[($nje + 1)..$#$nj])."\n";
autotest: implement much more thorough resumption verification the test will now make a test run for every journaled step, both right before and right after the logging.
2017-03-19 10:53:16 +00:00
if (!$nxc) {
print "Expected result:\n";
printchan($tx);
print "Actual result:\n";
autotest: transform ck*() => cmp*() this avoids the ugly and error-prone repeated reading of the state after a failure. cmpbox() had to be made non-destructive on the box state. readchan() had to be created.
2022-02-06 14:43:53 +00:00
printchan($nrtx);
autotest: implement much more thorough resumption verification the test will now make a test run for every journaled step, both right before and right after the logging.
2017-03-19 10:53:16 +00:00
}
print "Debug output:\n";
autotest: pass containers by reference this makes function prototypes a lot more useful for parameter checking.
2020-12-18 13:31:16 +00:00
print @$nret;
autotest: implement much more thorough resumption verification the test will now make a test run for every journaled step, both right before and right after the logging.
2017-03-19 10:53:16 +00:00
exit 1;
}
deprecate master/slave terminology the underlying metaphor refers to an inhumane practice, so using it casually is rightfully offensive to many people. it isn't even a particularly apt metaphor, as it suggests a strict hierarchy that is counter to mbsync's highly symmetrical mode of operation. the far/near terminology has been chosen as the replacement, as it is a natural fit for the push/pull terminology. on the downside, due to these not being nouns, a few uses are a bit awkward, and several others had to be amended to include 'side'. also, it's conceptually quite close to remote/local, which matches the typical use case, but is maybe a bit too suggestive of actually non-existing limitations. the new f/n suffixes of the -C/-R/-X options clash with pre-existing options, so direct concatenation of short options is even less practical than before (some suffixes of -D already clashed), but doing that leads to unreadable command lines anyway. as with previous deprecations, all pre-existing command line and config options keep working, but yield a warning. the state files are silently upgraded.
2020-07-22 17:44:26 +00:00
rmtree "near";
rmtree "far";
add autotest for message trashing
2022-04-04 16:55:14 +00:00
rmtree "near_trash";
rmtree "far_trash";
autotest: implement much more thorough resumption verification the test will now make a test run for every journaled step, both right before and right after the logging.
2017-03-19 10:53:16 +00:00
}
add forced async mode to proxy driver to test async operation of the syncing core while using the synchronous maildir driver, we add a mode to the proxy driver where it queues callback invocations to the next main loop iteration.
2020-12-14 22:16:01 +00:00
}
autotest: pass containers by reference this makes function prototypes a lot more useful for parameter checking.
2020-12-18 13:31:16 +00:00
# $title, \@source_state, \@target_state, \@channel_configs
sub test($$$$)
add forced async mode to proxy driver to test async operation of the syncing core while using the synchronous maildir driver, we add a mode to the proxy driver where it queues callback invocations to the next main loop iteration.
2020-12-14 22:16:01 +00:00
{
autotest: use more appropriate data formats parse the test data into hierarchical structures instead of using it in its raw form. this is semantically cleaner and allows us to change the input format more easily.
2022-01-23 23:33:53 +00:00
my ($ttl, $isx, $itx, $sfx) = @_;
add forced async mode to proxy driver to test async operation of the syncing core while using the synchronous maildir driver, we add a mode to the proxy driver where it queues callback invocations to the next main loop iteration.
2020-12-14 22:16:01 +00:00
autotest: add support for starting at a specific test ... which is often useful for continuation after test data fixes.
2022-01-26 17:46:58 +00:00
if (@match) {
if ($start) {
return if (index($ttl, $match[0]) < 0);
@match = ();
} else {
return if (!grep { index($ttl, $_) >= 0 } @match);
}
}
add forced async mode to proxy driver to test async operation of the syncing core while using the synchronous maildir driver, we add a mode to the proxy driver where it queues callback invocations to the next main loop iteration.
2020-12-14 22:16:01 +00:00
print "Testing: ".$ttl." ...\n";
autotest: pass containers by reference this makes function prototypes a lot more useful for parameter checking.
2020-12-18 13:31:16 +00:00
writecfg($sfx);
add forced async mode to proxy driver to test async operation of the syncing core while using the synchronous maildir driver, we add a mode to the proxy driver where it queues callback invocations to the next main loop iteration.
2020-12-14 22:16:01 +00:00
autotest: use more appropriate data formats parse the test data into hierarchical structures instead of using it in its raw form. this is semantically cleaner and allows us to change the input format more easily.
2022-01-23 23:33:53 +00:00
my $sx = parse_chan($isx);
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
my $tx = parse_chan($itx, $sx);
autotest: use more appropriate data formats parse the test data into hierarchical structures instead of using it in its raw form. this is semantically cleaner and allows us to change the input format more easily.
2022-01-23 23:33:53 +00:00
autotest: pass containers by reference this makes function prototypes a lot more useful for parameter checking.
2020-12-18 13:31:16 +00:00
test_impl(0, $sx, $tx, $sfx);
test_impl(1, $sx, $tx, $sfx);
test also one-sided async operation this tests only the common case of the far side being async - adding 100% instead of 50% to the runtime of the test to cover a corner case didn't seem worth it.
2022-06-01 11:54:48 +00:00
test_impl(2, $sx, $tx, $sfx);
autotest: implement much more thorough resumption verification the test will now make a test run for every journaled step, both right before and right after the logging.
2017-03-19 10:53:16 +00:00
killcfg();
add some regression testing.
2005-12-22 18:06:25 +00:00
}
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
################################################################################
# Format of the test defs:
# ( max_pulled, max_expired, max_pushed, { subject, far, state, near }... )
# Everything is a delta; for the input, the reference is the empty state.
# Common commands:
# *f => create with flags, appending at end of list
# / => destroy
# -f, +f => remove/add flags
# Far/near:
# Special commands:
# _ => create phantom message (reserve UID for expunged message)
# ^f => create with flags, duplicating the subject
add autotest for message trashing
2022-04-04 16:55:14 +00:00
# # => create in trash; deletion may follow
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
# | => use zero UID for state modification, even if msg exists; cmd may follow
# & => use zero UID for state identification, even if message exists
# &n => use UID of n'th occurence of subject for state id; command may follow
# Special flag suffixes:
# * => big
# ? => placeholder
# State:
# Special commands:
# <, > => update far/near message link; flag updates may follow
# ^f => create with flags, appending right after last command's entry
# Special flag prefixes as in actual state file.
# Generic syncing tests
my @x01 = (
rework maxuid tracking yet again re-introduce newmaxuid, but now it's not used at all until the state is committed. this simplifies the new-message loop, esp. in view of a soon significantly increased number of branches in it.
2021-12-10 20:45:51 +00:00
I, 0, I,
R, "*", "", "", # Skipped/failed messages to prevent maxuid topping
S, "", "", "*",
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
A, "*F", "*", "*",
B, "*", "*", "*F",
C, "*FS", "*", "*F",
D, "*", "*", "*",
E, "*T", "*", "*",
don't propagate about-to-be-expunged messages while we already refrained from propagating messages that would be expunged from the target, we still propagated ones that would be expunged from the source. this would lead to the weird situation of creating orphans, and would pose journal replay idempotence problems. such messages will now never have a sync record, so it becomes pointless to test for S_PENDING in the trashing loop. note that the behavior was previously bogus: these messages would have been paired by the end of the run, so we shouldn't have treated them as solo for the purposes of TrashOnlyNew/TrashRemoteNew.
2022-02-10 19:27:31 +00:00
F, "*", "*", "*T",
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
G, "*F", "*", "_",
H, "*FT", "*", "*",
I, "_", "*", "*",
don't propagate about-to-be-expunged messages while we already refrained from propagating messages that would be expunged from the target, we still propagated ones that would be expunged from the source. this would lead to the weird situation of creating orphans, and would pose journal replay idempotence problems. such messages will now never have a sync record, so it becomes pointless to test for S_PENDING in the trashing loop. note that the behavior was previously bogus: these messages would have been paired by the end of the run, so we shouldn't have treated them as solo for the purposes of TrashOnlyNew/TrashRemoteNew.
2022-02-10 19:27:31 +00:00
J, "*T", "", "",
fix resuming propagation of flags on new messages log the flags as soon as we know them, and commit them when the uid is assigned (including during tuid matching). amends 25b1c2b9.
2022-02-07 19:01:03 +00:00
K, "*P", "", "",
don't propagate about-to-be-expunged messages while we already refrained from propagating messages that would be expunged from the target, we still propagated ones that would be expunged from the source. this would lead to the weird situation of creating orphans, and would pose journal replay idempotence problems. such messages will now never have a sync record, so it becomes pointless to test for S_PENDING in the trashing loop. note that the behavior was previously bogus: these messages would have been paired by the end of the run, so we shouldn't have treated them as solo for the purposes of TrashOnlyNew/TrashRemoteNew.
2022-02-10 19:27:31 +00:00
L, "", "", "*T",
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
M, "", "", "*",
);
my @O01 = ("", "", "");
my @X01 = (
M, 0, K,
A, "", "+F", "+F",
B, "+F", "+F", "",
C, "", "+FS", "+S",
E, "", "+T", "+T",
don't propagate about-to-be-expunged messages while we already refrained from propagating messages that would be expunged from the target, we still propagated ones that would be expunged from the source. this would lead to the weird situation of creating orphans, and would pose journal replay idempotence problems. such messages will now never have a sync record, so it becomes pointless to test for S_PENDING in the trashing loop. note that the behavior was previously bogus: these messages would have been paired by the end of the run, so we shouldn't have treated them as solo for the purposes of TrashOnlyNew/TrashRemoteNew.
2022-02-10 19:27:31 +00:00
F, "+T", "+T", "",
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
G, "+T", ">", "",
H, "", "+FT", "+FT",
I, "", "<", "+T",
don't propagate about-to-be-expunged messages while we already refrained from propagating messages that would be expunged from the target, we still propagated ones that would be expunged from the source. this would lead to the weird situation of creating orphans, and would pose journal replay idempotence problems. such messages will now never have a sync record, so it becomes pointless to test for S_PENDING in the trashing loop. note that the behavior was previously bogus: these messages would have been paired by the end of the run, so we shouldn't have treated them as solo for the purposes of TrashOnlyNew/TrashRemoteNew.
2022-02-10 19:27:31 +00:00
L, "*T", "*T", "",
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
M, "*", "*", "",
don't propagate about-to-be-expunged messages while we already refrained from propagating messages that would be expunged from the target, we still propagated ones that would be expunged from the source. this would lead to the weird situation of creating orphans, and would pose journal replay idempotence problems. such messages will now never have a sync record, so it becomes pointless to test for S_PENDING in the trashing loop. note that the behavior was previously bogus: these messages would have been paired by the end of the run, so we shouldn't have treated them as solo for the purposes of TrashOnlyNew/TrashRemoteNew.
2022-02-10 19:27:31 +00:00
J, "", "*T", "*T",
fix resuming propagation of flags on new messages log the flags as soon as we know them, and commit them when the uid is assigned (including during tuid matching). amends 25b1c2b9.
2022-02-07 19:01:03 +00:00
K, "", "*P", "*P",
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
);
test("full", \@x01, \@X01, \@O01);
my @O02 = ("", "", "Expunge Both\n");
my @X02 = (
M, 0, K,
A, "", "+F", "+F",
B, "+F", "+F", "",
C, "", "+FS", "+S",
E, "/", "/", "/",
don't propagate about-to-be-expunged messages while we already refrained from propagating messages that would be expunged from the target, we still propagated ones that would be expunged from the source. this would lead to the weird situation of creating orphans, and would pose journal replay idempotence problems. such messages will now never have a sync record, so it becomes pointless to test for S_PENDING in the trashing loop. note that the behavior was previously bogus: these messages would have been paired by the end of the run, so we shouldn't have treated them as solo for the purposes of TrashOnlyNew/TrashRemoteNew.
2022-02-10 19:27:31 +00:00
F, "/", "/", "/",
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
G, "/", "/", "",
H, "/", "/", "/",
I, "", "/", "/",
don't propagate about-to-be-expunged messages while we already refrained from propagating messages that would be expunged from the target, we still propagated ones that would be expunged from the source. this would lead to the weird situation of creating orphans, and would pose journal replay idempotence problems. such messages will now never have a sync record, so it becomes pointless to test for S_PENDING in the trashing loop. note that the behavior was previously bogus: these messages would have been paired by the end of the run, so we shouldn't have treated them as solo for the purposes of TrashOnlyNew/TrashRemoteNew.
2022-02-10 19:27:31 +00:00
J, "/", "", "",
L, "", "", "/",
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
M, "*", "*", "",
fix resuming propagation of flags on new messages log the flags as soon as we know them, and commit them when the uid is assigned (including during tuid matching). amends 25b1c2b9.
2022-02-07 19:01:03 +00:00
K, "", "*P", "*P",
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
);
test("full + expunge both", \@x01, \@X02, \@O02);
my @O03 = ("", "", "Expunge Near\n");
my @X03 = (
M, 0, K,
A, "", "+F", "+F",
B, "+F", "+F", "",
C, "", "+FS", "+S",
E, "", ">+T", "/",
don't propagate about-to-be-expunged messages while we already refrained from propagating messages that would be expunged from the target, we still propagated ones that would be expunged from the source. this would lead to the weird situation of creating orphans, and would pose journal replay idempotence problems. such messages will now never have a sync record, so it becomes pointless to test for S_PENDING in the trashing loop. note that the behavior was previously bogus: these messages would have been paired by the end of the run, so we shouldn't have treated them as solo for the purposes of TrashOnlyNew/TrashRemoteNew.
2022-02-10 19:27:31 +00:00
F, "+T", ">+T", "/",
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
G, "+T", ">", "",
H, "", ">+T", "/",
I, "", "/", "/",
don't propagate about-to-be-expunged messages while we already refrained from propagating messages that would be expunged from the target, we still propagated ones that would be expunged from the source. this would lead to the weird situation of creating orphans, and would pose journal replay idempotence problems. such messages will now never have a sync record, so it becomes pointless to test for S_PENDING in the trashing loop. note that the behavior was previously bogus: these messages would have been paired by the end of the run, so we shouldn't have treated them as solo for the purposes of TrashOnlyNew/TrashRemoteNew.
2022-02-10 19:27:31 +00:00
L, "", "", "/",
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
M, "*", "*", "",
fix resuming propagation of flags on new messages log the flags as soon as we know them, and commit them when the uid is assigned (including during tuid matching). amends 25b1c2b9.
2022-02-07 19:01:03 +00:00
K, "", "*P", "*P",
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
);
test("full + expunge near side", \@x01, \@X03, \@O03);
my @O04 = ("", "", "Sync Pull\n");
my @X04 = (
rework maxuid tracking yet again re-introduce newmaxuid, but now it's not used at all until the state is committed. this simplifies the new-message loop, esp. in view of a soon significantly increased number of branches in it.
2021-12-10 20:45:51 +00:00
K, 0, I,
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
A, "", "+F", "+F",
C, "", "+FS", "+S",
E, "", "+T", "+T",
H, "", "+FT", "+FT",
I, "", "<", "+T",
don't propagate about-to-be-expunged messages while we already refrained from propagating messages that would be expunged from the target, we still propagated ones that would be expunged from the source. this would lead to the weird situation of creating orphans, and would pose journal replay idempotence problems. such messages will now never have a sync record, so it becomes pointless to test for S_PENDING in the trashing loop. note that the behavior was previously bogus: these messages would have been paired by the end of the run, so we shouldn't have treated them as solo for the purposes of TrashOnlyNew/TrashRemoteNew.
2022-02-10 19:27:31 +00:00
J, "", "*T", "*T",
fix resuming propagation of flags on new messages log the flags as soon as we know them, and commit them when the uid is assigned (including during tuid matching). amends 25b1c2b9.
2022-02-07 19:01:03 +00:00
K, "", "*P", "*P",
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
);
test("pull", \@x01, \@X04, \@O04);
my @O05 = ("", "", "Sync Flags\n");
my @X05 = (
rework maxuid tracking yet again re-introduce newmaxuid, but now it's not used at all until the state is committed. this simplifies the new-message loop, esp. in view of a soon significantly increased number of branches in it.
2021-12-10 20:45:51 +00:00
I, 0, I,
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
A, "", "+F", "+F",
B, "+F", "+F", "",
C, "", "+FS", "+S",
E, "", "+T", "+T",
don't propagate about-to-be-expunged messages while we already refrained from propagating messages that would be expunged from the target, we still propagated ones that would be expunged from the source. this would lead to the weird situation of creating orphans, and would pose journal replay idempotence problems. such messages will now never have a sync record, so it becomes pointless to test for S_PENDING in the trashing loop. note that the behavior was previously bogus: these messages would have been paired by the end of the run, so we shouldn't have treated them as solo for the purposes of TrashOnlyNew/TrashRemoteNew.
2022-02-10 19:27:31 +00:00
F, "+T", "+T", "",
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
H, "", "+FT", "+FT",
);
test("flags", \@x01, \@X05, \@O05);
my @O06 = ("", "", "Sync Delete\n");
my @X06 = (
rework maxuid tracking yet again re-introduce newmaxuid, but now it's not used at all until the state is committed. this simplifies the new-message loop, esp. in view of a soon significantly increased number of branches in it.
2021-12-10 20:45:51 +00:00
I, 0, I,
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
G, "+T", ">", "",
I, "", "<", "+T",
);
test("deletions", \@x01, \@X06, \@O06);
my @O07 = ("", "", "Sync New\n");
my @X07 = (
M, 0, K,
don't propagate about-to-be-expunged messages while we already refrained from propagating messages that would be expunged from the target, we still propagated ones that would be expunged from the source. this would lead to the weird situation of creating orphans, and would pose journal replay idempotence problems. such messages will now never have a sync record, so it becomes pointless to test for S_PENDING in the trashing loop. note that the behavior was previously bogus: these messages would have been paired by the end of the run, so we shouldn't have treated them as solo for the purposes of TrashOnlyNew/TrashRemoteNew.
2022-02-10 19:27:31 +00:00
L, "*T", "*T", "",
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
M, "*", "*", "",
don't propagate about-to-be-expunged messages while we already refrained from propagating messages that would be expunged from the target, we still propagated ones that would be expunged from the source. this would lead to the weird situation of creating orphans, and would pose journal replay idempotence problems. such messages will now never have a sync record, so it becomes pointless to test for S_PENDING in the trashing loop. note that the behavior was previously bogus: these messages would have been paired by the end of the run, so we shouldn't have treated them as solo for the purposes of TrashOnlyNew/TrashRemoteNew.
2022-02-10 19:27:31 +00:00
J, "", "*T", "*T",
fix resuming propagation of flags on new messages log the flags as soon as we know them, and commit them when the uid is assigned (including during tuid matching). amends 25b1c2b9.
2022-02-07 19:01:03 +00:00
K, "", "*P", "*P",
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
);
test("new", \@x01, \@X07, \@O07);
my @O08 = ("", "", "Sync PushFlags PullDelete\n");
my @X08 = (
rework maxuid tracking yet again re-introduce newmaxuid, but now it's not used at all until the state is committed. this simplifies the new-message loop, esp. in view of a soon significantly increased number of branches in it.
2021-12-10 20:45:51 +00:00
I, 0, I,
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
B, "+F", "+F", "",
C, "", "+F", "",
don't propagate about-to-be-expunged messages while we already refrained from propagating messages that would be expunged from the target, we still propagated ones that would be expunged from the source. this would lead to the weird situation of creating orphans, and would pose journal replay idempotence problems. such messages will now never have a sync record, so it becomes pointless to test for S_PENDING in the trashing loop. note that the behavior was previously bogus: these messages would have been paired by the end of the run, so we shouldn't have treated them as solo for the purposes of TrashOnlyNew/TrashRemoteNew.
2022-02-10 19:27:31 +00:00
F, "+T", "+T", "",
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
I, "", "<", "+T",
);
test("push flags + pull deletions", \@x01, \@X08, \@O08);
# Size restriction tests
my @x20 = (
0, 0, 0,
A, "*", "", "",
fix resuming propagation of flags on new messages log the flags as soon as we know them, and commit them when the uid is assigned (including during tuid matching). amends 25b1c2b9.
2022-02-07 19:01:03 +00:00
B, "*P*", "", "",
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
C, "", "", "**",
);
my @O21 = ("MaxSize 1k\n", "MaxSize 1k\n", "Expunge Near");
my @X21 = (
C, 0, B,
C, "*?", "*<", "",
A, "", "*", "*",
fix resuming propagation of flags on new messages log the flags as soon as we know them, and commit them when the uid is assigned (including during tuid matching). amends 25b1c2b9.
2022-02-07 19:01:03 +00:00
B, "", "*>P", "*P?",
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
);
test("max size", \@x20, \@X21, \@O21);
my @x22 = (
rework flag propagation during placeholder upgrade don't implicitly propagate flags with upgrades. the user asked for replacing the body, so do just that. if they also asked for flag propagation, handle it like the case without upgrade as far as possible. this makes async parallel flag propagation in the opposite direction robust, while still being reasonably simple.
2022-06-17 13:57:56 +00:00
E, 0, B,
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
A, "*", "", "",
rework flag propagation during placeholder upgrade don't implicitly propagate flags with upgrades. the user asked for replacing the body, so do just that. if they also asked for flag propagation, handle it like the case without upgrade as far as possible. this makes async parallel flag propagation in the opposite direction robust, while still being reasonably simple.
2022-06-17 13:57:56 +00:00
B, "*PR*", "", "",
C, "*PR?", "*<DP", "*DFP*",
D, "*PR?", "*<DP", "*DP*",
E, "*PR*", "*>DP", "*DP?",
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
A, "", "*", "*",
rework flag propagation during placeholder upgrade don't implicitly propagate flags with upgrades. the user asked for replacing the body, so do just that. if they also asked for flag propagation, handle it like the case without upgrade as far as possible. this makes async parallel flag propagation in the opposite direction robust, while still being reasonably simple.
2022-06-17 13:57:56 +00:00
B, "", "*>DP", "*DFP?",
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
);
my @X22 = (
C, 0, B,
rework flag propagation during placeholder upgrade don't implicitly propagate flags with upgrades. the user asked for replacing the body, so do just that. if they also asked for flag propagation, handle it like the case without upgrade as far as possible. this makes async parallel flag propagation in the opposite direction robust, while still being reasonably simple.
2022-06-17 13:57:56 +00:00
B, "", ">->D+R", "^PR*",
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
B, "", "", "&1/",
rework flag propagation during placeholder upgrade don't implicitly propagate flags with upgrades. the user asked for replacing the body, so do just that. if they also asked for flag propagation, handle it like the case without upgrade as far as possible. this makes async parallel flag propagation in the opposite direction robust, while still being reasonably simple.
2022-06-17 13:57:56 +00:00
C, "^FPR*", "<-<D+FR", "-D+R",
exclude placeholders from trashing it makes no sense to trash the placeholders, and in fact the common case is that they are deleted due to being replaced by the full message. a separate S_PURGED state needed to be added, as S_PURGE needs to be reset after setting F_DELETED (so the operation doesn't count as still pending after journal replay), yet trashing needs an indicator. logging is now done via a separate command, as piggy-backing it on flag updates just makes things less legible for no benefit. this is mostly academical, as trashing being done on the side where placeholders reside is rather unlikely.
2022-04-04 19:41:18 +00:00
C, "&1+T", "^", "&",
rework flag propagation during placeholder upgrade don't implicitly propagate flags with upgrades. the user asked for replacing the body, so do just that. if they also asked for flag propagation, handle it like the case without upgrade as far as possible. this makes async parallel flag propagation in the opposite direction robust, while still being reasonably simple.
2022-06-17 13:57:56 +00:00
D, "", "-D+R", "-D+R",
E, "", "-D+R", "-D+R",
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
);
test("max size + flagging", \@x22, \@X22, \@O21);
my @x23 = (
0, 0, 0,
A, "*", "", "",
B, "*F*", "", "",
C, "", "", "*F*",
);
my @X23 = (
C, 0, B,
C, "*F*", "*F", "",
A, "", "*", "*",
B, "", "*F", "*F*",
);
test("max size + initial flagging", \@x23, \@X23, \@O21);
my @x24 = (
C, 0, A,
A, "*", "*", "*",
B, "**", "*^", "",
fix resuming propagation of flags on new messages log the flags as soon as we know them, and commit them when the uid is assigned (including during tuid matching). amends 25b1c2b9.
2022-02-07 19:01:03 +00:00
C, "*FP*", "*^", "",
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
);
my @X24 = (
C, 0, C,
B, "", ">-^+>", "*?",
fix resuming propagation of flags on new messages log the flags as soon as we know them, and commit them when the uid is assigned (including during tuid matching). amends 25b1c2b9.
2022-02-07 19:01:03 +00:00
C, "", ">-^+FP", "*FP*",
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
);
test("max size (pre-1.4 legacy)", \@x24, \@X24, \@O21);
# Expiration tests
my @x30 = (
0, 0, 0,
A, "*F", "", "",
B, "*", "", "",
C, "*S", "", "",
D, "*", "", "",
E, "*S", "", "",
F, "*", "", "",
);
my @O31 = ("", "", "MaxMessages 3\n");
my @X31 = (
F, C, F,
A, "", "*F", "*F",
B, "", "*", "*",
D, "", "*", "*",
E, "", "*S", "*S",
F, "", "*", "*",
);
test("max messages", \@x30, \@X31, \@O31);
my @O32 = ("", "", "MaxMessages 3\nExpireUnread yes\n");
my @X32 = (
F, C, F,
A, "", "*F", "*F",
D, "", "*", "*",
E, "", "*S", "*S",
F, "", "*", "*",
);
test("max messages vs. unread", \@x30, \@X32, \@O32);
my @x38 = (
F, C, 0,
A, "*FS", "*FS", "*S",
B, "*FS", "*~S", "*ST",
C, "*S", "*~S", "_",
D, "*", "*", "*",
E, "*", "*", "*",
F, "*", "*", "*",
);
my @O38 = ("", "", "MaxMessages 3\nExpunge Both\n");
my @X38 = (
F, C, F,
A, "-F", "/", "/",
B, "", "-~+F", "-T+F",
C, "", "/", "",
);
test("max messages + expunge", \@x38, \@X38, \@O38);
rework maxuid tracking yet again re-introduce newmaxuid, but now it's not used at all until the state is committed. this simplifies the new-message loop, esp. in view of a soon significantly increased number of branches in it.
2021-12-10 20:45:51 +00:00
# Test for legacy/tampered states with inaccurate maxuid tracking
# Joined post-push & post-pull state to have just one test -
# there is no way how this could have occurred naturally.
my @x60 = (
0, C, 0,
A, "*S", "", "_",
B, "*FS", "*FS", "*FS",
C, "*S", "", "_",
D, "*", "*", "*",
E, "*", "*", "*",
F, "*", "", "",
G, "*", "", "",
H, "", "", "*",
I, "", "", "_",
J, "*", "*", "*",
);
my @O61 = ("", "", "Sync Flags\n"); # Need to fetch old messages
my @X61 = (
E, C, E,
);
test("maxuid topping", \@x60, \@X61, \@O61);
autotest skipping doomed messages more thoroughly ensure that the messages are actually skipped, not subsequently expunged.
2022-03-17 11:58:05 +00:00
# Messages that would be instantly expunged on the target side.
my @x90 = (
C, 0, C,
A, "*DRT*", "*>D", "*DFP?",
B, "*DR*", "*>D", "*DFPT?",
C, "*", "*", "*",
D, "*T", "", "",
);
my @O91 = ("", "", "Expunge Near\n", "-Tx");
my @X91 = (
D, 0, C,
A, "+P", ">+P", "|",
A, "&", "^", "+T",
B, "+PT", ">+PT", "|",
B, "&", "^", "",
);
test("doomed", \@x90, \@X91, \@O91);
add autotest for message trashing
2022-04-04 16:55:14 +00:00
# Trashing
my @x10 = (
exclude placeholders from trashing it makes no sense to trash the placeholders, and in fact the common case is that they are deleted due to being replaced by the full message. a separate S_PURGED state needed to be added, as S_PURGE needs to be reset after setting F_DELETED (so the operation doesn't count as still pending after journal replay), yet trashing needs an indicator. logging is now done via a separate command, as piggy-backing it on flag updates just makes things less legible for no benefit. this is mostly academical, as trashing being done on the side where placeholders reside is rather unlikely.
2022-04-04 19:41:18 +00:00
K, A, K,
add autotest for message trashing
2022-04-04 16:55:14 +00:00
A, "*", "*~", "*T",
B, "*T", "*^", "",
C, "*T", "*", "*T",
D, "_", "*", "*",
E, "*", "*", "_",
exclude placeholders from trashing it makes no sense to trash the placeholders, and in fact the common case is that they are deleted due to being replaced by the full message. a separate S_PURGED state needed to be added, as S_PURGE needs to be reset after setting F_DELETED (so the operation doesn't count as still pending after journal replay), yet trashing needs an indicator. logging is now done via a separate command, as piggy-backing it on flag updates just makes things less legible for no benefit. this is mostly academical, as trashing being done on the side where placeholders reside is rather unlikely.
2022-04-04 19:41:18 +00:00
F, "**", "*>", "*T?",
G, "*T?", "*<", "**",
autotest skipping doomed messages more thoroughly ensure that the messages are actually skipped, not subsequently expunged.
2022-03-17 11:58:05 +00:00
H, "**", "*>", "*FT?",
I, "*FT?", "*<", "**",
exclude placeholders from trashing it makes no sense to trash the placeholders, and in fact the common case is that they are deleted due to being replaced by the full message. a separate S_PURGED state needed to be added, as S_PURGE needs to be reset after setting F_DELETED (so the operation doesn't count as still pending after journal replay), yet trashing needs an indicator. logging is now done via a separate command, as piggy-backing it on flag updates just makes things less legible for no benefit. this is mostly academical, as trashing being done on the side where placeholders reside is rather unlikely.
2022-04-04 19:41:18 +00:00
J, "**", "*>", "*F?",
K, "*F?", "*<", "**",
add autotest for message trashing
2022-04-04 16:55:14 +00:00
L, "*T", "", "",
M, "", "", "*T",
R, "", "", "*", # Force maxuid in the interrupt-resume test.
S, "*", "", "",
);
my @O11 = ("Trash far_trash\n", "Trash near_trash\n",
"MaxMessages 20\nExpireUnread yes\nMaxSize 1k\nExpunge Both\n");
my @X11 = (
R, A, S,
A, "", "/", "/",
B, "#/", "/", "",
C, "#/", "/", "#/",
D, "", "/", "#/",
E, "#/", "/", "",
exclude placeholders from trashing it makes no sense to trash the placeholders, and in fact the common case is that they are deleted due to being replaced by the full message. a separate S_PURGED state needed to be added, as S_PURGE needs to be reset after setting F_DELETED (so the operation doesn't count as still pending after journal replay), yet trashing needs an indicator. logging is now done via a separate command, as piggy-backing it on flag updates just makes things less legible for no benefit. this is mostly academical, as trashing being done on the side where placeholders reside is rather unlikely.
2022-04-04 19:41:18 +00:00
F, "#/", "/", "/",
G, "/", "/", "#/",
autotest skipping doomed messages more thoroughly ensure that the messages are actually skipped, not subsequently expunged.
2022-03-17 11:58:05 +00:00
H, "#/", "/", "/",
I, "/", "/", "#/",
exclude placeholders from trashing it makes no sense to trash the placeholders, and in fact the common case is that they are deleted due to being replaced by the full message. a separate S_PURGED state needed to be added, as S_PURGE needs to be reset after setting F_DELETED (so the operation doesn't count as still pending after journal replay), yet trashing needs an indicator. logging is now done via a separate command, as piggy-backing it on flag updates just makes things less legible for no benefit. this is mostly academical, as trashing being done on the side where placeholders reside is rather unlikely.
2022-04-04 19:41:18 +00:00
J, "", ">->", "^*",
J, "", "", "&1/",
K, "^*", "<-<", "",
K, "&1/", "", "",
add autotest for message trashing
2022-04-04 16:55:14 +00:00
L, "#/", "", "",
M, "", "", "#/",
R, "*", "*", "",
S, "", "*", "*",
);
test("trash", \@x10, \@X11, \@O11);
my @O12 = ("Trash far_trash\n", "Trash near_trash\nTrashNewOnly true\n",
"MaxMessages 20\nExpireUnread yes\nMaxSize 1k\nExpunge Both\n");
my @X12 = (
R, A, S,
A, "", "/", "/",
B, "#/", "/", "",
C, "#/", "/", "/",
D, "", "/", "/",
E, "#/", "/", "",
exclude placeholders from trashing it makes no sense to trash the placeholders, and in fact the common case is that they are deleted due to being replaced by the full message. a separate S_PURGED state needed to be added, as S_PURGE needs to be reset after setting F_DELETED (so the operation doesn't count as still pending after journal replay), yet trashing needs an indicator. logging is now done via a separate command, as piggy-backing it on flag updates just makes things less legible for no benefit. this is mostly academical, as trashing being done on the side where placeholders reside is rather unlikely.
2022-04-04 19:41:18 +00:00
F, "#/", "/", "/",
G, "/", "/", "#/",
autotest skipping doomed messages more thoroughly ensure that the messages are actually skipped, not subsequently expunged.
2022-03-17 11:58:05 +00:00
H, "#/", "/", "/",
I, "/", "/", "#/",
exclude placeholders from trashing it makes no sense to trash the placeholders, and in fact the common case is that they are deleted due to being replaced by the full message. a separate S_PURGED state needed to be added, as S_PURGE needs to be reset after setting F_DELETED (so the operation doesn't count as still pending after journal replay), yet trashing needs an indicator. logging is now done via a separate command, as piggy-backing it on flag updates just makes things less legible for no benefit. this is mostly academical, as trashing being done on the side where placeholders reside is rather unlikely.
2022-04-04 19:41:18 +00:00
J, "", ">->", "^*",
J, "", "", "&1/",
K, "^*", "<-<", "",
K, "&1/", "", "",
add autotest for message trashing
2022-04-04 16:55:14 +00:00
L, "#/", "", "",
M, "", "", "#/",
R, "*", "*", "",
S, "", "*", "*",
);
test("trash only new", \@x10, \@X12, \@O12);
my @O13 = ("Trash far_trash\nTrashRemoteNew true\n", "",
"MaxMessages 20\nExpireUnread yes\nMaxSize 1k\nExpunge Both\n");
my @X13 = (
R, A, S,
A, "", "/", "/",
B, "#/", "/", "",
C, "#/", "/", "/",
D, "", "/", "/",
E, "#/", "/", "",
exclude placeholders from trashing it makes no sense to trash the placeholders, and in fact the common case is that they are deleted due to being replaced by the full message. a separate S_PURGED state needed to be added, as S_PURGE needs to be reset after setting F_DELETED (so the operation doesn't count as still pending after journal replay), yet trashing needs an indicator. logging is now done via a separate command, as piggy-backing it on flag updates just makes things less legible for no benefit. this is mostly academical, as trashing being done on the side where placeholders reside is rather unlikely.
2022-04-04 19:41:18 +00:00
F, "#/", "/", "/",
G, "#/", "/", "/",
autotest skipping doomed messages more thoroughly ensure that the messages are actually skipped, not subsequently expunged.
2022-03-17 11:58:05 +00:00
H, "#/", "/", "/",
I, "#/", "/", "/",
exclude placeholders from trashing it makes no sense to trash the placeholders, and in fact the common case is that they are deleted due to being replaced by the full message. a separate S_PURGED state needed to be added, as S_PURGE needs to be reset after setting F_DELETED (so the operation doesn't count as still pending after journal replay), yet trashing needs an indicator. logging is now done via a separate command, as piggy-backing it on flag updates just makes things less legible for no benefit. this is mostly academical, as trashing being done on the side where placeholders reside is rather unlikely.
2022-04-04 19:41:18 +00:00
J, "", ">->", "^*",
J, "", "", "&1/",
K, "^*", "<-<", "",
K, "&1/", "", "",
add autotest for message trashing
2022-04-04 16:55:14 +00:00
L, "#/", "", "",
M, "#", "", "/",
R, "*", "*", "",
S, "", "*", "*",
);
test("trash new remotely", \@x10, \@X13, \@O13);
autotest: use more legible format for test data instead of specifying the mailboxes and sync state verbatim, use a format which deals only with "subjects" (but no UIDs), and specifies the whole state for each subject on a single line (exceptions prove the rule). the dumpers don't try to re-create the abstraction, as that's deemed to be an unreasonable effort. while rewriting most of the test data anyway, move it to the bottom of the file, which is a more natural location for it.
2022-02-20 12:00:55 +00:00
print "OK.\n";
Reference in New Issue Copy Permalink