Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 166 insertions, 0 deletions

diff --git a/comm/mailnews/imap/test/TestImapFlagAndUidState.cpp b/comm/mailnews/imap/test/TestImapFlagAndUidState.cpp
new file mode 100644
index 0000000000..a7658322b8
--- /dev/null
+++ b/comm/mailnews/imap/test/TestImapFlagAndUidState.cpp
@@ -0,0 +1,166 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#include <stdio.h>
+#include "TestHarness.h"
+#include "nsCOMPtr.h"
+#include "msgCore.h"
+#include "nsImapProtocol.h"
+
+struct msgState {
+  uint32_t uid;
+  uint16_t flag;
+  uint32_t index;
+};
+
+char errorMsg[200];
+
+const char* MainChecks(nsImapFlagAndUidState* flagState,
+                       struct msgState* expectedState, uint32_t numMessages,
+                       uint32_t expectedNumUnread) {
+  // Verify that flag state matches the expected state.
+  for (uint32_t i = 0; i < numMessages; i++) {
+    uint32_t uid;
+    uint16_t flag;
+    flagState->GetUidOfMessage(expectedState[i].index, &uid);
+    flagState->GetMessageFlags(expectedState[i].index, &flag);
+    if (uid != expectedState[i].uid) {
+      PR_snprintf(errorMsg, sizeof(errorMsg),
+                  "expected uid %d, got %d at index %d\n", expectedState[i].uid,
+                  uid, i);
+      return errorMsg;
+    }
+    if (flag != expectedState[i].flag) {
+      PR_snprintf(errorMsg, sizeof(errorMsg),
+                  "expected flag %d, got %d at index %d\n",
+                  expectedState[i].flag, flag, i);
+      return errorMsg;
+    }
+  }
+  int32_t numMsgsInFlagState;
+  int32_t numUnread = 0;
+  int32_t expectedMsgIndex = 0;
+
+  flagState->GetNumberOfMessages(&numMsgsInFlagState);
+  for (int32_t msgIndex = 0; msgIndex < numMsgsInFlagState; msgIndex++) {
+    uint32_t uidOfMessage;
+    flagState->GetUidOfMessage(msgIndex, &uidOfMessage);
+    if (!uidOfMessage || uidOfMessage == nsMsgKey_None) continue;
+    if (uidOfMessage != expectedState[expectedMsgIndex++].uid) {
+      PR_snprintf(
+          errorMsg, sizeof(errorMsg),
+          "got a uid w/o a match in expected state, uid %d at index %d\n",
+          uidOfMessage, msgIndex);
+      return errorMsg;
+    }
+    imapMessageFlagsType flags;
+    flagState->GetMessageFlags(msgIndex, &flags);
+    if (!(flags & kImapMsgSeenFlag)) numUnread++;
+  }
+  if (numUnread != expectedNumUnread) {
+    PR_snprintf(errorMsg, sizeof(errorMsg),
+                "expected %d unread message, got %d\n", expectedNumUnread,
+                numUnread);
+    return errorMsg;
+  }
+  return nullptr;
+}
+
+// General note about return values:
+// return 1 for a setup or xpcom type failure, return 2 for a real test failure
+int main(int argc, char** argv) {
+  ScopedXPCOM xpcom("TestImapFlagAndUidState.cpp");
+  if (xpcom.failed()) return 1;
+
+  struct msgState msgState1[] = {{10, kImapMsgSeenFlag, 0},
+                                 {15, kImapMsgSeenFlag, 1},
+                                 {16, kImapMsgSeenFlag, 2},
+                                 {17, kImapMsgSeenFlag, 3},
+                                 {18, kImapMsgSeenFlag, 4}};
+
+  RefPtr<nsImapFlagAndUidState> flagState = new nsImapFlagAndUidState(10);
+  int32_t numMsgs = sizeof(msgState1) / sizeof(msgState1[0]);
+  for (int32_t i = 0; i < numMsgs; i++)
+    flagState->AddUidFlagPair(msgState1[i].uid, msgState1[i].flag,
+                              msgState1[i].index);
+
+  const char* error = MainChecks(flagState, msgState1, numMsgs, 0);
+  if (error) {
+    printf("TEST-UNEXPECTED-FAIL | %s | %s\n", __FILE__, error);
+    return 1;
+  }
+
+  // Now reset all
+  flagState->Reset();
+
+  // This tests adding some messages to a partial uid flag state,
+  // i.e., CONDSTORE.
+  struct msgState msgState2[] = {{68, kImapMsgSeenFlag, 69},
+                                 {71, kImapMsgSeenFlag, 70},
+                                 {73, kImapMsgSeenFlag, 71}};
+  numMsgs = sizeof(msgState2) / sizeof(msgState2[0]);
+  for (int32_t i = 0; i < numMsgs; i++)
+    flagState->AddUidFlagPair(msgState2[i].uid, msgState2[i].flag,
+                              msgState2[i].index);
+  error = MainChecks(flagState, msgState2, numMsgs, 0);
+  if (error) {
+    printf("TEST-UNEXPECTED-FAIL | %s | %s\n", __FILE__, error);
+    return 1;
+  }
+  // Reset all
+  flagState->Reset();
+  // This tests generating a uid string from a non-sequential set of
+  // messages where the first message is not in the flag state, but the
+  // missing message from the sequence is in the set. I.e., we're
+  // generating a uid string from 69,71, but only 70 and 71 are in
+  // the flag state.
+  struct msgState msgState3[] = {{10, kImapMsgSeenFlag, 0},
+                                 {69, kImapMsgSeenFlag, 1},
+                                 {70, kImapMsgSeenFlag, 2},
+                                 {71, kImapMsgSeenFlag, 3}};
+
+  flagState->SetPartialUIDFetch(false);
+  numMsgs = sizeof(msgState3) / sizeof(msgState3[0]);
+  for (int32_t i = 0; i < numMsgs; i++)
+    flagState->AddUidFlagPair(msgState3[i].uid, msgState3[i].flag,
+                              msgState3[i].index);
+  flagState->ExpungeByIndex(2);
+  nsCString uidString;
+  uint32_t msgUids[] = {69, 71};
+  uint32_t msgCount = 2;
+  AllocateImapUidString(&msgUids[0], msgCount, flagState, uidString);
+  if (!uidString.EqualsLiteral("71")) {
+    printf("TEST-UNEXPECTED-FAIL | uid String is %s, not 71 | %s\n",
+           uidString.get(), __FILE__);
+    return -1;
+  }
+  // Reset all
+  flagState->Reset();
+  // This tests the middle message missing from the flag state.
+  struct msgState msgState4[] = {{10, kImapMsgSeenFlag, 0},
+                                 {69, kImapMsgSeenFlag, 1},
+                                 {70, kImapMsgSeenFlag, 2},
+                                 {71, kImapMsgSeenFlag, 3},
+                                 {73, kImapMsgSeenFlag, 4}};
+
+  flagState->SetPartialUIDFetch(false);
+  numMsgs = sizeof(msgState4) / sizeof(msgState4[0]);
+  for (int32_t i = 0; i < numMsgs; i++)
+    flagState->AddUidFlagPair(msgState4[i].uid, msgState4[i].flag,
+                              msgState4[i].index);
+  flagState->ExpungeByIndex(4);
+  uint32_t msgUids2[] = {69, 71, 73};
+  msgCount = 3;
+  nsCString uidString2;
+
+  AllocateImapUidString(&msgUids2[0], msgCount, flagState, uidString2);
+  if (!uidString2.EqualsLiteral("69,73")) {
+    printf("TEST-UNEXPECTED-FAIL | uid String is %s, not 71 | %s\n",
+           uidString.get(), __FILE__);
+    return -1;
+  }
+
+  printf("TEST-PASS | %s | all tests passed\n", __FILE__);
+  return 0;
+}