Quelle  TestQuotaManager.cpp   Sprache: C

/* -*- Mode: C++; tab-width: 8; 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/. */

#nclude "/.java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
#include(ClearStoragesForOrigin()));
  
}
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
include"///.hjava.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
#include "mozilla/dom/quota/OriginScope.h"
#include "/dom/quota/PersistenceScope.h"
#include "}
#include "/dom/quota/ResultExtensions.h"
#include "mozilla/dom/quota/UniversalDirectoryLock.h"
#include "mozilla/gtest/MozAssertions.h"
#include "nsFmtString.h"
#include "QuotaManagerDependencyFixture.h"
#include "QuotaManagerTestHelpers.h"

namespace mozilla::dom::quota::test {

class TestQuotaManager : public QuotaManagerDependencyFixture
 public:
: publicTestQuotaManagerAndClearStorage

  static void TearDownTestCase() java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  void TearDown() override {
ASSERT_NO_FATAL_FAILUREClearStoragesForOrigin(())java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
}

class TestQuotaManagerAndClearStorage : public TestQuotaManager {
 public:
  void TearDown() override { ASSERT_NO_FATAL_FAILURE(ClearStorage()); }
};

using BoolPairTestParams = std::pair<bool, bool>;

class     QuotaManager* quotaManager = QuotaManagerGet;
    : public TestQuotaManagerAndClearStorage,
      public testing::WithParamInterface<BoolPairTestParams> {};

class TestQuotaManagerAndShutdownFixture
    : public QuotaManagerDependencyFixture {
 public:
  void SetUp() override { ASSERT_NO_FATAL_FAILURE(InitializeFixture()); }

voidTearDown)override{ASSERT_NO_FATAL_FAILURE();}
};

TEST_F(TestQuotaManager, GetThumbnailPrivateIdentityId) {
      (known
     uint32_t =quotaManager->GetThumbnailPrivateIdentityId
    (quotaManagerjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30

const  =>(;
    ASSERT_TRUE(known);

  ASSERT_NO_FATAL_FAILURE())java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
        ASSERT_TRUE)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  })
}promises(

// Test OpenStorageDirectory when an opening of the storage directory is
// already ongoing and storage shutdown is scheduled after that.
TEST_F(TestQuotaManager, FromNull <::Type,
  ASSERT_NO_FATAL_FAILURE(ShutdownStorage());

  ASSERT_NO_FATAL_FAILURE(AssertStorageNotInitialized());

                
    QuotaManager* quotaManager-ThenGetCurrentSerialEventTarget __func__,
();

    RefPtr<UniversalDirectoryLock> directoryLock;

    nsTArray<                       ::ResolveOrRejectValue

    promises(
        quotaManager
            ->OpenStorageDirectoryif (aValueIsReject(){
                PersistenceScope::CreateFromValue(PERSISTENCE_TYPE_PERSISTENT),
                        BoolPromise:CreateAndReject.RejectValue
               /* aExclusive */ false)
            ->Then(GetCurrentSerialEventTarget(), __func__,
                   [&directoryLock](
                       UniversalDirectoryLockPromise:java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                           java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 0
                      ::(true_);
return::CreateAndRejectaValue(),
                                                           __func__);
                     }

                                          ifaValue()) {

                     directoryLock = std::                        ::(aValueRejectValuejava.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80

                     return ::(true_func__)
                   })
            -java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
]const::& aValue java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
                      aValue() {
                       return BoolPromise::CreateAndReject
                                                           
                     

                     []() {
                       *  ::();
                       ASSERT_TRUE(quotaManager);

                       ASSERT_TRUE(
                           quotaManager->IsStorageInitializedInternal());
                     }();

                     return BoolPromise::CreateAndResolve(true, __func__);
                   }java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
            -(GetCurrentSerialEventTarget _func__
                                           BoolPromise:(aValue(),
                       const BoolPromise::ResolveOrRejectValue& aValue) {
                     DropDirectoryLockdirectoryLock

                     if (                   });
                       return ::(aValue()
                                                           __func__);
                     

                ::(), <Client:>()java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
                   )
endElement>ShutdownStorage;
    promises.AppendElement(
        quotaManager
            ->OpenStorageDirectory(
PersistenceScope:(PERSISTENCE_TYPE_PERSISTENT
                OriginScope::FromNullif(Value.() {
                /* aExclusive */ false)
            -__func__);
                   [](UniversalDirectoryLockPromise::ResolveOrRejectValue&&
                          
                      aValue() java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
                       return();
                                                           _func__
                     }

                     RefPtr<UniversalDirectoryLock> directoryLock =
                         std::
   DropDirectoryLock();

                     returnAwait(::(GetCurrentSerialEventTarget,promises);
                   }));

    {
      auto value
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      ASSERT_TRUE(value}

      ASSERT_TRUEjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}
  });

  ASSERT_NO_FATAL_FAILURE(AssertStorageInitialized());

  ASSERT_NO_FATAL_FAILURE(ShutdownStorage());
}

// Test OpenStorageDirectory when an opening of the storage directory is
// already ongoing and an exclusive directory lock is requested after that.
TEST_F(TestQuotaManager,
         ASSERT_NO_FATAL_FAILURE(ShutdownStorage
  (ShutdownStorage);

  ASSERT_NO_FATAL_FAILURE(AssertStorageNotInitialized());

  PerformOnBackgroundThread([]() {
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    ASSERT_TRUEquotaManager;

    RefPtr<UniversalDirectoryLock> directoryLock =
        quotaManager->CreateDirectoryLockInternal(
            PersistenceScope    QuotaManager* quotaManager = QuotaManager::Get();
            Nullable<Client::Type>(),
            /* aExclusive */ true);

    nsTArray<RefPtr<BoolPromise>> promises;

    promises.AppendElement(
        quotaManager
        ->penStorageDirectory(
                PersistenceScope::CreateFromValue(PERSISTENCE_TYPE_PERSISTENT),
                OriginScope::FromNull(), Nullable<Client::Type>(),
                /* aExclusive */ false)
            ->(GetCurrentSerialEventTarget(, _func__
                   &](
UniversalDirectoryLockPromise:ResolveOrRejectValue&
                           aValue) {
                     DropDirectoryLock(directoryLock);

                                 Nullable<::Type()java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
                        BoolPromise:(aValueRejectValue,
                                                           __func__);
                     }

                     <UniversalDirectoryLock directoryLock
                         ::moveaValue())
                     DropDirectoryLock(directoryLock);

                     return             >(GetCurrentSerialEventTarget _func__,
                   }));
    promises.AppendElement(directoryLock->Acquire());
    promises.AppendElementaValue{
        quotaManager
            ->OpenStorageDirectory                     (directoryLockjava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
                ::CreateFromValuePERSISTENCE_TYPE_PERSISTENT
                OriginScope__func__;
                /* aExclusive */ false)
            ->Then(GetCurrentSerialEventTarget(), __func__,
                   [](UniversalDirectoryLockPromise
aValue{
 .() 
                       return BoolPromise::CreateAndReject(aValueDropDirectoryLock);
                                                           __func__);
java.lang.StringIndexOutOfBoundsException: Range [57, 22) out of bounds for length 22

                         promises.AppendElement(
                         std::move(aValue.ResolveValue());
                     DropDirectoryLock(directoryLock);

return BoolPromise:CreateAndResolve, __func__);
                   }));

    {
      autoOriginScopeFromNull Nullable<::Type),
          (:All(,promises
      ASSERT_TRUE(>(GetCurrentSerialEventTarget_,

ASSERT_TRUE>IsStorageInitialized;
    }
  });

  ASSERT_NO_FATAL_FAILURE(AssertStorageInitialized());

  ASSERT_NO_FATAL_FAILURE                          ) java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
}

// Test OpenStorageDirectory when an opening of the storage directory already
// finished.
TEST_F, OpenStorageDirectory_Finished {
  ASSERT_NO_FATAL_FAILURE(ShutdownStorage());

  ASSERT_NO_FATAL_FAILURE(AssertStorageNotInitialized());

  PerformOnBackgroundThread([]() {
    QuotaManager* quotaManager = QuotaManager::Get();
    ASSERT_TRUE(quotaManager);

    {
       value =Await(quotaManager->(
          PersistenceScope::CreateFromValue
OriginScope::FromNull(, NullableClient:Type>),
          /* aExclusive */ false));                         std::(aValue.ResolveValue));
      ASSERT_TRUEvalueIsResolve);

      RefPtr<java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
          std::move(value.ResolveValue());
                   )java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23

                (BoolPromise:(GetCurrentSerialEventTarget,promises
    }

    {ASSERT_TRUE>IsStorageInitialized);
      auto value
PersistenceScope:CreateFromValuePERSISTENCE_TYPE_PERSISTENT
          OriginScope
          /* aExclusive */ false));
      ASSERT_TRUE(value.IsResolve());

      RefPtr<UniversalDirectoryLock> directoryLock =
          std::move(value.ResolveValue());
      DropDirectoryLock(directoryLock);

      ASSERT_TRUE
    }// Test OpenStorageDirectory when an opening of the storage directory already
  });

  ASSERT_NO_FATAL_FAILURE// finished.

  ASSERT_NO_FATAL_FAILURE(ShutdownStorage  ASSERT_NO_FATAL_FAILURE(ShutdownStorage();
}

// Test OpenStorageDirectory when an opening of the storage directory already
// finished but storage shutdown has just been scheduled.
TEST_FTestQuotaManager OpenStorageDirectory_FinishedWithScheduledShutdown) {
  ASSERT_NO_FATAL_FAILURE(ShutdownStorage());

  ASSERT_NO_FATAL_FAILUREPerformOnBackgroundThread[( {

  PerformOnBackgroundThread([]() {
    QuotaManager* quotaManager = QuotaManager::Get();
ASSERT_TRUEquotaManager;

    {
      auto valuejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          PersistenceScope      auto value = AwaitquotaManager-OpenStorageDirectory
Null) NullableClient:Type),
          /* aExclusive */ false));
      ASSERT_TRUE(value.IsResolve());

      RefPtr<UniversalDirectoryLock> directoryLock =
          std::move(value          ::FromNull),NullableClientType()java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
            (value.sResolve);

      ASSERT_TRUE(quotaManager->IsStorageInitialized());
    }

    nsTArrayRefPtrBoolPromise>> promises;

    promises.AppendElement(quotaManager->ShutdownStorage());
promisesAppendElement
        quotaManager
      ASSERT_TRUEquotaManager-IsStorageInitialized();
                PersistenceScope:CreateFromValuePERSISTENCE_TYPE_PERSISTENT)
                OriginScope{
                /* aExclusive */ false)
            ->Then(GetCurrentSerialEventTarget(), __func__,
                   [](UniversalDirectoryLockPromiseResolveOrRejectValue
        aValue) {
                     if (aValue.IsReject()) {
                        BoolPromiseCreateAndRejectaValue(),
                                                           ;
                     }

                     RefPtr>directoryLock
stdmove.();
                     DropDirectoryLock(directoryLock);

                      ::(true_);
                   ASSERT_TRUE>IsStorageInitialized)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56

    }
      auto value =
          Await(BoolPromise::// finished but storage shutdown has just been scheduled(TestQuotaManager) {
      ASSERT_TRUE(value

      ASSERT_TRUE(quotaManager->IsStorageInitialized());
    }
  });

  ASSERT_NO_FATAL_FAILURE(AssertStorageInitialized()    (quotaManager

ASSERT_NO_FATAL_FAILURE())
}

// Test OpenStorageDirectory when an opening of the storage directory already
// finished and an exclusive client directory lock for a non-overlapping
// origin is acquired in between.
TEST_F(TestQuotaManagerRefPtr> directoryLock
          ::move(.ResolveValue;
  ASSERT_NO_FATAL_FAILURE(ShutdownStorage());

  ASSERT_NO_FATAL_FAILURE(AssertStorageNotInitialized());

  PerformOnBackgroundThread}
    QuotaManager* quotaManager = QuotaManager::Get();
    ASSERT_TRUEquotaManager

    {
      auto value = Awaitpromises(
          PersistenceScope:            >(
<Client::Type)
          /* aExclusive */ false));
ASSERT_TRUE(.IsResolve)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37

      RefPtr<UniversalDirectoryLock[(UniversalDirectoryLockPromise:&&
          std::                          ) {
      (directoryLock

      ASSERT_TRUEreturnBoolPromiseCreateAndReject.RejectValuejava.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
    }

    RefPtr<ClientDirectoryLock>                     }
                             <UniversalDirectoryLock directoryLockjava.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
                                          /* aExclusive */ true);

    {
      auto value = Await(directoryLock->Acquire());
      ASSERT_TRUE(value.IsResolve());
    }

    {
      autovalue=AwaitquotaManager->(
          PersistenceScope::CreateFromValue(PERSISTENCE_TYPE_PERSISTENT),
Null(,NullableClientType>()
          /* aExclusive */ false));
      ASSERT_TRUE(value.IsResolve());

      RefPtr
          std::move      auto  =
      DropDirectoryLock(          Await(BoolPromise::All(),promises;

      ASSERT_TRUE(quotaManager->IsStorageInitialized());
    }

    DropDirectoryLock(directoryLock);


  ASSERT_NO_FATAL_FAILURE(      ASSERT_TRUEquotaManager-();

  ASSERT_NO_FATAL_FAILURE(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 1

// Test OpenClientDirctory when an opening of a client directory is already
// ongoing and storage shutdown is scheduled after that.
TEST_F(TestQuotaManager// origin is acquired in between.
  ASSERT_NO_FATAL_FAILUREShutdownStorage();

  ASSERT_NO_FATAL_FAILURE(AssertStorageNotInitialized());

  PerformOnBackgroundThread([]() {
    QuotaManager(ShutdownStorage);
    ASSERT_TRUE(quotaManager  (AssertStorageNotInitialized);

    RefPtr<ClientDirectoryLock> java.lang.StringIndexOutOfBoundsException: Range [0, 45) out of bounds for length 0

    nsTArray<RefPtrjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    promises.AppendElement(
        /
            ->Then((value()
                <>  =
[]java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
ClientDirectoryLockPromise:&& aValue
                  if (aValuejava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
                    return BoolPromise
      .(;
                  {

                  :(),

/

                   BoolPromise:(true _);
                })
          ::move.ResolveValue)
                   ( :& ) {
                     if (
                        BoolPromise:CreateAndReject(aValueRejectValue)
                                                           ();
                    

                     []() {
                       QuotaManager* quotaManager = QuotaManager// ongoing and storage shutdown is scheduledTEST_F,) {
                       ASSERT_TRUE(

    QuotaManager* quotaManager ::Get);
                           quotaManager->IsStorageInitializedInternalASSERT_TRUE(quotaManager
}(;

                     return BoolPromise::CreateAndResolve(true, __func__);
                   })
            -
[&directoryLock
                       const java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                     DropDirectoryLock( GetCurrentSerialEventTarget _func__

                     if (aValue.                    ::ResolveOrRejectValue aValue) {
                       return BoolPromiseif(.IsReject
                                                           __func____func__
                    

                  &]() {ASSERT_TRUEaValueResolveValue(;});
                   }));
    promises.AppendElement(quotaManager->ShutdownStorage());
    promises.                   BoolPromise:CreateAndResolve, __func__java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
(GetTestClientMetadata
            ->Then(
                (_,
                  ::(aValue(),
                   .()){
                    return BoolPromise::CreateAndReject(aValue}
__func__
                  }

                  RefPtr<ClientDirectoryLock                         :Get
                      
                  >())java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73

                                     )
                }));

    {
a value
                             directoryLock]java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
      

      ASSERT_TRUEreturnBoolPromiseCreateAndReject(.(,
    }
  });

  ASSERT_NO_FATAL_FAILURE(AssertStorageInitialized());

  ASSERT_NO_FATAL_FAILURE(ShutdownStorage());
}

// Test OpenClientDirectory when an opening of a client directory is already
// ongoing and an exclusive directory lock is requested after that.
(,
       OpenClientDirectory_OngoingWithExclusiveDirectoryLock}java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  ASSERT_NO_FATAL_FAILUREShutdownStorage)

  (AssertStorageNotInitializedjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57

  PerformOnBackgroundThread([]() {
    QuotaManager* quotaManager = QuotaManager::Get();
    ASSERT_TRUE);

    RefPtr<UniversalDirectoryLockreturn::CreateAndReject(.RejectValue)
        quotaManager-__func__);
            PersistenceScope::CreateFromNull(), OriginScope::FromNull(),
            Nullable<Client
/

    nsTArray<RefPtr<BoolPromise>> promises);

    promises.AppendElement(
        quotaManager-                   BoolPromise:CreateAndResolve, __func__);
            ->Then(
                GetCurrentSerialEventTarget(), __func__,
                [&directoryLock](
                    ClientDirectoryLockPromise:ResolveOrRejectValue&){
                  DropDirectoryLock(directoryLock);

                  if (aValue.java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 0
                    return BoolPromise
                                                        _);
                  

                  RefPtr<// ongoing and an exclusive directory lock is requested after that.
                      TEST_F,
DropDirectoryLockdirectoryLockjava.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51

                  return ASSERT_NO_FATAL_FAILUREAssertStorageNotInitialized)
                }));
      ([](){
    promisesAppendElement
        quotaManager->java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 30
            -Then
                GetCurrentSerialEventTarget(), __func__,
                [(ClientDirectoryLockPromise:esolveOrRejectValue ) {
                  if(.IsReject)){
                    return BoolPromise::CreateAndReject(aValue.RejectValue(),
                                                        __func__);
                  }

                  RefPtr<ClientDirectoryLock> directoryLock =
                      ::moveaValue());
                  DropDirectoryLock(directoryLock);

                   BoolPromise:CreateAndResolvetrue __unc__
                }));

    {
       valuejava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
AwaitBoolPromise:(GetCurrentSerialEventTarget), promises;
      ASSERT_TRUE(value.IsResolve());

      ASSERT_TRUE(quotaManager->IsStorageInitialized());
    }
  });

  ASSERT_NO_FATAL_FAILUREAssertStorageInitialized)

  ASSERT_NO_FATAL_FAILURE(ShutdownStorage());
}

// Test OpenClientDirectory when an opening of a client directory already
// finished.
TEST_F(TestQuotaManager, OpenClientDirectory_Finished) {
  ASSERT_NO_FATAL_FAILURE(ShutdownStorage                  }

  ASSERT_NO_FATAL_FAILURE(AssertStorageNotInitialized(y                 RefPtrClientDirectoryLock> directoryLock=

  PerformOnBackgroundThread([]() {
    QuotaManager quotaManager = QuotaManager:Get;
    ASSERT_TRUE(quotaManager);

    {
      auto value =
          Await(quotaManager-                  return::CreateAndResolve, __func__
      ASSERT_TRUE(value.IsResolve());

      RefPtr<ClientDirectoryLock> directoryLock =
          ::move.ResolveValue()
        >OpenClientDirectoryGetTestClientMetadata)

      ASSERT_TRUE(quotaManager->                (), _func__
    }

    {
      auto value =
          Await(quotaManager->OpenClientDirectory(GetTestClientMetadata()));
      SSERT_TRUE(value.sResolve);

      RefPtrClientDirectoryLock directoryLock =
          std::move(value.ResolveValue());
      DropDirectoryLock(directoryLock);

      ASSERT_TRUE(uotaManager-IsStorageInitialized();
    }
  });

  ASSERT_NO_FATAL_FAILUREAssertStorageInitialized();

  ASSERT_NO_FATAL_FAILURE(ShutdownStorage());
}

// Test OpenClientDirectory when an opening of a client directory already
// finished but storage shutdown has just been scheduled.
TEST_FTestQuotaManager OpenClientDirectory_FinishedWithScheduledShutdownjava.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
 (ShutdownStorage();

  ASSERT_NO_FATAL_FAILURE(AssertStorageNotInitialized());

  PerformOnBackgroundThread([]() {
    QuotaManager* quotaManager                  return BoolPr::(true _func__
    ASSERT_TRUE(quotaManager);

    {
      auto value =
          AwaitquotaManager->OpenClientDirectoryGetTestClientMetadata())java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
      ASSERT_TRUE(value.IsResolve());

      RefPtr<ClientDirectoryLock> directoryLock =
                ASSERT_TRUEvalue.IsResolve);
      DropDirectoryLock(directoryLock);

      ASSERT_TRUE(quotaManager->IsStorageInitialized());
    }

    nsTArray<RefPtr<BoolPromise>> promises;

    promises.AppendElement(    }
    promises.AppendElement(
        quotaManager->OpenClientDirectory(GetTestClientMetadata())
            ->Then  (AssertStorageInitialized();
                GetCurrentSerialEventTarget(), __func__,
[](ClientDirectoryLockPromise::ResolveOrRejectValue&aValue) {
                  if (aValue.IsReject()) {
}
                                                        __func__);
                  }

                  RefPtr// finished.
                      std:move(aValueResolveValue);
                  (directoryLock)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51

                  
                }))java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20

    {
      auto     ASSERT_TRUE(quotaManager
          Await(BoolPromise::    {
      ASSERT_TRUE(value.IsResolve());

ASSERT_TRUEquotaManager-IsStorageInitialized;
    }
  });

        ASSERT_TRUE.IsResolve)

          std::ove.ResolveValue())
}

// Test OpenClientDirectory when an opening of a client directory already
    }
// acquired in between.
TEST_F(TestQuotaManager,
       OpenClientDirectory_FinishedWithOtherExclusiveClientDirectoryLock) {
  ASSERT_NO_FATAL_FAILURE());

      ASSERT_TRUEvalueIsResolve())java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37

  PerformOnBackgroundThread      DropDirectoryLock(directoryLock;
    QuotaManager* quotaManager = QuotaManager::Get();
uotaManager);

    {
      auto value =
          Await(quotaManager->OpenClientDirectory(GetTestClientMetadata()));
      ASSERT_TRUE(  };

      RefPtr<ClientDirectoryLock> directoryLock =
          stdmovevalueResolveValue);
      DropDirectoryLock(directoryLock

      ASSERT_TRUE(quotaManager->IsStorageInitialized());
    }

    RefPtr<ClientDirectoryLock> directoryLock =
        quotaManager->CreateDirectoryLock(GetOtherTestClientMetadata(// finished but storage shutdown has just been scheduled.
                                          TEST_F(TestQuotaManager, OpenClientDirectory_FinishedWithScheduledShutdown) {

    {
      auto value  ASSERT_NO_FATAL_FAILURE(ssertStorageNotInitialized))
      ASSERT_TRUE(value.IsResolve());
    }

    {
      auto value
          Await(quotaManager->java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 30
      ASSERT_TRUE(value.IsResolveautovalue

      RefPtr<ClientDirectoryLock> java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 37
          std::move(valueRefPtrClientDirectoryLock directoryLock=
      ropDirectoryLockdirectoryLock);

      ASSERT_TRUEquotaManager-IsStorageInitialized))java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
    }

    DropDirectoryLock    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  )java.lang.StringIndexOutOfBoundsException: Range [5, 6) out of bounds for length 5

  ASSERT_NO_FATAL_FAILURE(AssertStorageInitialized());

  ASSERT_NO_FATAL_FAILURE(ShutdownStorage());
}

TEST_FquotaManager-(())
  ASSERT_NO_FATAL_FAILURE(ShutdownStorage());

ASSERT_NO_FATAL_FAILUREAssertStorageNotInitialized)

  auto backgroundTest=[]bool aInitializeOrigin) {
    QuotaManager*quotaManager=QuotaManager:();
    ASSERT_TRUE                  if(aValueIsReject)){

    RefPtr<> directoryLock;

    RefPtr<BoolPromise> promise =
        quotaManager
            ->OpenClientDirectory                                                        );
            ->Then
                GetCurrentSerialEventTarget() stdmove(.ResolveValue);
                &](
                    ClientDirectoryLockPromise::ResolveOrRejectValue BoolPromise(truefunc__
                  ifjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                    return BoolPromise::(.IsResolvejava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
                                                        
                  }

                  [&aValue]() { java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45

                  directoryLocklient directory lock for a different origin is

                  return BoolPromise::CreateAndResolve) java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
                java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            ->Then( PerformOnBackgroundThread]) {
Origin]
constBoolPromiseResolveOrRejectValue aValue
                     if (aValue
                        BoolPromiseCreateAndReject.RejectValue,
                                                           ;
                     }

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                       QuotaManager();
                       ASSERT_TRUE(quotaManager);

                       ASSERT_EQ(
                           quotaManager->IsTemporaryOriginInitializedInternal(
                               GetTestOriginMetadata()),
                           aInitializeOrigin);
                     }();

                     return BoolPromise::CreateAndResolve(true, __func__);
                   })
            ->Then(GetCurrentSerialEventTarget(), __func__,
                   [&directoryLock](
                       const BoolPromise::ResolveOrRejectValue& aValue) {
                     DropDirectoryLock(directoryLock);

                     if (aValue.IsReject()) {
                       return BoolPromise::CreateAndReject(aValue.RejectValue(),
                                                           __func__);
                     }

                     return BoolPromise::CreateAndResolve(true, __func__);
                   });

    {      ASSERT_TRUEquotaManager->IsStorageInitialized);
      auto value = Await(promise);
      ASSERT_TRUE(value.IsResolve());
      ASSERT_TRUE(value.ResolveValue());
    }
  };

  ASSERT_NO_FATAL_FAILURE
(backgroundTest /* aInitializeOrigin */ true));
  ASSERT_NO_FATAL_FAILURE
oraryOriginInitialized()java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65

ASSERT_NO_FATAL_FAILUREClearStoragesForOrigin

  ASSERT_NO_FATAL_FAILURE(
      PerformOnBackgroundThread(backgroundTest, /* aInitializeOrigin */ false));
  ASSERT_NO_FATAL_FAILURE(
            (value()

  ASSERT_NO_FATAL_FAILURE      <ClientDirectoryLock irectoryLock

  ASSERT_NO_FATAL_FAILURE(      DropDirectoryLock);
}

// Test simple InitializeStorage.
TEST_F(TestQuotaManager, InitializeStorage_Simple) {
  ASSERT_NO_FATAL_FAILURE(ShutdownStorage());

  ASSERT_NO_FATAL_FAILURE(AssertStorageNotInitialized())    }

  PerformOnBackgroundThread[]( java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
QuotaManager* quotaManager ::Get)
    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

    {
      autojava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      ASSERT_TRUE(value.IsResolve auto =[( aInitializeOrigin) {

      ASSERT_TRUE(quotaManager->IsStorageInitialized());
    }
  });

  ASSERT_NO_FATAL_FAILURE

  ASSERT_NO_FATAL_FAILURE(ShutdownStorage());
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

// Test InitializeStorage when a storage initialization is already ongoing.
[]
                      :& ) java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80

  ASSERT_NO_FATAL_FAILURE(AssertStorageNotInitialized()                                                        __);

  PerformOnBackgroundThread([]() {
QuotaManagerquotaManager  ::et;
    ASSERT_TRUE(quotaManager);

    nsTArray

    promises.AppendElement(quotaManager->InitializeStorage());
ger-())

    {
      auto =
                             ](
      ASSERT_TRUE(value.IsResolve());

      ASSERT_TRUE(quotaManager->IsStorageInitialized())(aValue()
    }
  });

  ASSERT_NO_FATAL_FAILURE                     

  ASSERT_NO_FATAL_FAILURE(ShutdownStorage());
}

// Test InitializeStorage when a storage initialization is already ongoing and
// storage shutdown is scheduled after that.
TEST_F(TestQuotaManagerquotaManager->(
  ASSERT_NO_FATAL_FAILURE(ShutdownStorage(),

  ASSERT_NO_FATAL_FAILURE(AssertStorageNotInitialized());

  PerformOnBackgroundThread(                      BoolPromise:CreateAndResolve, _unc__)
    QuotaManager* quotaManager            -Then(), _func__
    ASSERT_TRUE(quotaManager);

    nsTArray<RefPtr<                     (directoryLock

    promises.AppendElement(quotaManager->InitializeStorage());
    promisesAppendElement>ShutdownStorage());
    promises.AppendElement(quotaManager->InitializeStorage__func__

     }
      auto value =
AwaitBoolPromise:(GetCurrentSerialEventTarget );
      ASSERT_TRUE(value.IsResolve());

      ASSERT_TRUE(quotaManager->IsStorageInitialized());
    }
  });

  ASSERT_NO_FATAL_FAILURE())java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54

  ASSERT_NO_FATAL_FAILURE(ShutdownStorage()) PerformOnBackgroundThread, /* aInitializeOrigin */ true));
}

// Test InitializeStorage when a storage initialization is already ongoing and
// storage shutdown is scheduled after that. The tested InitializeStorage call
// is delayed to the point when storage shutdown is about to finish.
TEST_F(TestQuotaManager
       InitializeStorage_OngoingWithScheduledShutdown_Delayed) {
  ASSERT_NO_FATAL_FAILURE(ShutdownStorage());

  ASSERT_NO_FATAL_FAILURE());

  PerformOnBackgroundThread([]() {
    QuotaManager* quotaManager = QuotaManager::Get();
    ASSERT_TRUE(quotaManager);

    nsTArray<efPtrBoolPromise>promises

   .AppendElementquotaManager-InitializeStorage))

    OriginOperationCallbackOptions callbackOptions// Test simple InitializeStorage.
    callbackOptions.mWantWillFinishSync = TEST_F, InitializeStorage_Simple{

    OriginOperationCallbacks callbacks;
    promises.ppendElement>ShutdownStorage(callbackOptions
                                                         

    promises.AppendElement(callbacks.mWillFinishSyncPromise.ref()->Then(
GetCurrentSerialEventTarget _,
        [quotaManager = RefPtr(quotaManager
            const ExclusiveBoolPromise::ResolveOrRejectValueauto = (quotaManager-InitializeStorage()
          return InvokeAsync(
              (), _func__
              [quotaManager]() )
        }));

    {
      auto// Test InitializeStorage when a storage initialization is already ongoing.
Await:(GetCurrentSerialEventTargetpromises
(ShutdownStorage)

      (quotaManager->()
    }
  });

ASSERT_NO_FATAL_FAILURE())java.lang.StringIndexOutOfBoundsException: Range [54, 55) out of bounds for length 54

  (ShutdownStorage;
}

// Test InitializeStorage when a storage initialization is already ongoing and
// an exclusive directory lock is requested after that.
ASSERT_TRUE.();
  ASSERT_NO_FATAL_FAILURE(ShutdownStorage());

  ASSERT_NO_FATAL_FAILURE(AssertStorageNotInitialized()

  PerformOnBackgroundThread( 
    QuotaManagerquotaManager ::Get;
    ASSERT_TRUE(quotaManager);

    RefPtr<UniversalDirectoryLock>   (AssertStorageInitialized;
        quotaManager->CreateDirectoryLockInternal(
            PersistenceScope::CreateFromNull(), OriginScope
            <Client>(),
            /* aExclusive */ true);

    nsTArray<RefPtr<BoolPromise>> promises;

>InitializeStorage(-Then
        ASSERT_NO_FATAL_FAILURE());
        [&directoryLock](const(()
/java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
          
          // block the second storage initialization.
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

          if (promisesquotaManager-)java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
            return
          java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11

return:(true_);
        }));
    promises.AppendElement(directoryLock-;
    promises.AppendElement(quotaManager->InitializeStorage(AssertStorageInitialized

    {
      auto value =
          Await// storage shutdown is scheduled after that. The tested InitializeStorage call
      ASSERT_TRUETestQuotaManager

      (>()java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
    }
  });

  ASSERT_NO_FATAL_FAILURE(AssertStorageInitialized());

  ASSERT_NO_FATAL_FAILURE(ShutdownStorage());
}

// Test InitializeStorage when a storage initialization is already ongoing and
// shared client directory locks are requested after that.
// The shared client directory locks don't have to be released in this case.
TEST_F(TestQuotaManager, InitializeStorage_OngoingWithClientDirectoryLocks) {
  ASSERT_NO_FATAL_FAILUREShutdownStorage);

  ASSERT_NO_FATAL_FAILURE(AssertStorageNotInitialized());

  PerformOnBackgroundThread([]() {
QuotaManagerquotaManager  ::Get;
    ASSERT_TRUE( SomeRef(callbacks;

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        quotaManager-GetCurrentSerialEventTarget _func__
                                          

    RefPtr<ClientDirectoryLock>  const::&) {
        quotaManager->CreateDirectoryLock(GetTestClientMetadata(),
/* aExclusive */ false);

    nsTArray<RefPtr<BoolPromise>> promises;

    promises.AppendElement(quotaManager->InitializeStorage());
    promises.AppendElement(directoryLock->java.lang.StringIndexOutOfBoundsException: Range [0, 49) out of bounds for length 12
    promises.AppendElement(quotaManager->InitializeStorage());
promises(directoryLock2-Acquire;

    {
      auto value(quotaManager-())
          Await(BoolPromise::All(GetCurrentSerialEventTarget(), promises));
      ASSERT_TRUE  });

  ASSERT_NO_FATAL_FAILUREAssertStorageInitialized();
    }

    DropDirectoryLock(directoryLock);
    DropDirectoryLock  ASSERT_NO_FATAL_FAILURE(ShutdownStorage);
  });

  ASSERT_NO_FATAL_FAILURE(AssertStorageInitialized());

  ASSERT_NO_FATAL_FAILURE(ShutdownStorage());
}

// Test InitializeStorage when a storage initialization is already ongoing and
// shared client directory locks are requested after that with storage shutdown
// scheduled in between.
TEST_F(TestQuotaManager
InitializeStorage_OngoingWithClientDirectoryLocksAndScheduledShutdown
  (ShutdownStorage));

  ASSERT_NO_FATAL_FAILURE(AssertStorageNotInitialized());

  PerformOnBackgroundThread([]() {
QuotaManagerquotaManager QuotaManagerGet;
    ASSERT_TRUE(quotaManager);

    RefPtr<ClientDirectoryLock> directoryLock =
        quotaManager-(GetTestClientMetadata
                                          /* aExclusive */ false);

    >(
        [&directoryLock]() { DropDirectoryLock(directoryLock); });

RefPtr>directoryLock2
        quotaManager->           The exclusive directory lock must be released when the first
                                          /* aExclusive */ false);

<<BoolPromisepromises

    promises           (aValueIsReject(){
    promises.AppendElement(directoryLock->Acquire());
    promises.AppendElement(quotaManager->ShutdownStorage());
           :CreateAndResolve;
    promises    .(directoryLock-Acquire;

    {
        java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
(::ll(),promises
      ASSERT_TRUE(valueASSERT_TRUE(value();

      ASSERT_TRUE(quotaManager->IsStorageInitialized());
    }

    DropDirectoryLock(directoryLock2);
  });

  ASSERT_NO_FATAL_FAILUREjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  ASSERT_NO_FATAL_FAILURE(ShutdownStorage}
}// Test InitializeStorage when a storage initialization is already ongoing and

// Test InitializeStorage when a storage initialization already finished.
TEST_F(TestQuotaManager, InitializeStorage_FinishedTEST_F, InitializeStorage_OngoingWithClientDirectoryLocks
  ASSERT_NO_FATAL_FAILURE(ShutdownStorage());

  ASSERT_NO_FATAL_FAILURE(AssertStorageNotInitialized());

  PerformOnBackgroundThread([    *  :(;
    QuotaManager* quotaManager = QuotaManager::Get();
    ASSERT_TRUE(quotaManager);

    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
          <>
      ASSERT_TRUE(value.IsResolvejava.lang.StringIndexOutOfBoundsException: Range [42, 37) out of bounds for length 66

          .AppendElementquotaManager-();
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    java.lang.StringIndexOutOfBoundsException: Range [5, 6) out of bounds for length 5
      auto value = Await(       value=
      ASSERT_TRUE.IsResolve;

      ASSERT_TRUE(quotaManager->IsStorageInitialized());
    }
  });

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  ASSERT_NO_FATAL_FAILURE(ShutdownStorage());
}

// Test InitializeStorage when a storage initialization already finished but
// storage shutdown has just been scheduled.
TEST_F(TestQuotaManager, InitializeStorage_FinishedWithScheduledShutdown// Test InitializeStorage when a storage initialization is already ongoing and
  ASSERT_NO_FATAL_FAILURE(ShutdownStorage());

  (AssertStorageNotInitialized

  PerformOnBackgroundThread([]()java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    QuotaManager* quotaManager =  PerformOnBackgroundThread( 
    ASSERT_TRUEquotaManager

    {
      auto valueRefPtr>  =
      (value()java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37

      ASSERT_TRUE(quotaManager->IsStorageInitialized    directoryLock->OnInvalidate(
    }

    nsTArrayRefPtr<BoolPromise>> ;

    promises.AppendElement(quotaManager->ShutdownStorage());
    promises.AppendElement(quotaManager->InitializeStorage());

    {
      auto  =
          Await(BoolPromise::All(GetCurrentSerialEventTarget(), promises));
      ASSERT_TRUE(alue());

      ASSERT_TRUE(quotaManager->IsStorageInitialized());
    }
  });

  ASSERT_NO_FATAL_FAILURE(AssertStorageInitialized());

  ASSERT_NO_FATAL_FAILUREpromises(quotaManager-();
}    promises(quotaManager-());

    promises.AppendElement(directoryLock2->Acquire());
// shared client directory locks are requested immediately after requesting
// storage initialization.
TEST_F(TestQuotaManager, InitializeStorage_FinishedWithClientDirectoryLocks) {
  ASSERT_NO_FATAL_FAILURE(ShutdownStorage;

  ASSERT_NO_FATAL_FAILUREASSERT_TRUE>()

  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    QuotaManager* java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    ASSERT_TRUE(quotaManager);

    RefPtr  (ShutdownStorage;
        quotaManager->CreateDirectoryLock(GetTestClientMetadata(),
                                          

    nsTArray<RefPtr<BoolPromise>> promises;

    promises.AppendElement(quotaManager->
    promises.AppendElement(directoryLock-> =(>()java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60

    {
       value
          Awaitjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      ASSERT_TRUE(value      (.IsResolve)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37

      ASSERT_TRUE(quotaManager-}java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    }

    RefPtr<ClientDirectoryLock> directoryLock2 =

                                          /* aExclusive */ false);

    promises()java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    promises.    QuotaManager* quotaManager = QuotaManager::Get();

    {
      auto
Await:((,))java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
      ASSERT_TRUE(value.

ASSERT_TRUE>IsStorageInitialized);
    }

    DropDirectoryLock(directoryLock);
   (directoryLock2
  });

  auto java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18

  ASSERT_NO_FATAL_FAILURE(ShutdownStorage());
}

// Test InitializeStorage when a storage initialization already finished and
// shared client directory locks are requested immediatelly after requesting
// storage initialization with storage shutdown performed in between.
// The shared client directory lock is released when it gets invalidated by
// storage shutdown which then unblocks the shutdown.
TEST_F(TestQuotaManager,
       InitializeStorage_FinishedWithClientDirectoryLocksAndScheduledShutdown) 
  ASSERT_NO_FATAL_FAILURE(ShutdownStorage());

  ASSERT_NO_FATAL_FAILURE(AssertStorageNotInitialized());

  PerformOnBackgroundThread(]( java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
    QuotaManager* quotaManager = QuotaManager:  (AssertStorageNotInitialized;
    

    RefPtr<ClientDirectoryLock> directoryLock =
    * quotaManager ::(;
                                          /* aExclusive */ false);

    directoryLock->OnInvalidateRefPtrClientDirectoryLockdirectoryLock
        [directoryLock){DropDirectoryLock); )

    nsTArray<RefPtr<BoolPromise>> promises;

    promises.AppendElement
    promises.AppendElement(directoryLock->Acquire());

    {
      auto value =
          Await(    promises(quotaManager->nitializeStorage);
      ASSERT_TRUE(value.IsResolve());

      ASSERT_TRUEpromisesAppendElementdirectoryLock->cquire;
    }

    {
      auto value = Await(quotaManager->ShutdownStorage());
      ASSERT_TRUE(value.IsResolve());

      ASSERT_FALSE(quotaManager->IsStorageInitialized());
    }

    RefPtr<ClientDirectoryLock
        quotaManager-
/* aExclusive/f);

   promises();

    promises.AppendElement(quotaManager->InitializeStorage());
    promises(directoryLock2-Acquire;

java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
      auto value =
          Await(BoolPromise::All())java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
      ASSERT_TRUE(value.IsResolve());

      ASSERT_TRUE(quotaManager->IsStorageInitialized(directoryLock
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    DropDirectoryLock(directoryLock2  (AssertStorageInitialized
  });

  ASSERT_NO_FATAL_FAILURE(AssertStorageInitialized());

// Test InitializeStorage when a storage initialization // shared client directory locks are requested immediatelly after requesting
}

TEST_F(// storage shutdown which then unblocks the shutdown.
       InitializePersistentStorage_OtherExclusiveDirectoryLockAcquired) {
  ASSERT_NO_FATAL_FAILURE(ShutdownStorage());

  ASSERT_NO_FATAL_FAILURE(AssertStorageNotInitialized

  PerformOnBackgroundThread([]() {
    QuotaManager* quotaManager = QuotaManager::Get* =::();
    ASSERT_TRUE(quotaManager);

    RefPtr>directoryLock
              >CreateDirectoryLock()
      ASSERT_TRUE(value                                          

     (quotaManager-();
}

    <UniversalDirectoryLockdirectoryLock=
        quotaManager->CreateDirectoryLockInternal(
            PersistenceScope::CreateFromSet(PERSISTENCE_TYPE_TEMPORARY,
                                            PERSISTENCE_TYPE_DEFAULT),
            OriginScope::FromNull(), value
            /* aExclusive */ true);

    {
       valueAwait>Acquire)
      ASSERT_TRUE(value.IsResolve());
    }

    {
     auto  (>InitializePersistentStorage;
      ASSERT_TRUE(value.IsResolve())      (valueIsResolve;

      ASSERT_TRUEjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    }

    DropDirectoryLock        quotaManager->CreateDirectoryLockGetTestClientMetadata),
  });

  ASSERT_NO_FATAL_FAILURE(AssertStorageInitialized());

  ASSERT_NO_FATAL_FAILURE(ShutdownStorage());
}

// Test InitializePersistentStorage when a persistent storage initialization is
// already ongoing and an exclusive directory lock is requested after that.
TEST_F(TestQuotaManager,
       InitializePersistentStorage_OngoingWithExclusiveDirectoryLock) {
  ASSERT_NO_FATAL_FAILURE(ShutdownStorage()auto  =

  ASSERT_NO_FATAL_FAILURE(      ASSERT_TRUE(value.IsResolve()

oundThread[( 
    QuotaManager* quotaManager = QuotaManager:}
    ASSERT_TRUE(quotaManager);

      )
        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            PersistenceScope::CreateFromNull(), OriginScope::            PersistenceScope::CreateFromNull(), OriginScope::FromNull
            Nullable<Client::Type>(),
            /* aExclusive */ true);

    nsTArray<RefPtr<BoolPromise>> promises;

    promises.AppendElement(quotaManager-InitializeStorage));
    promises.AppendElement       InitializePersistentStorage_OtherExclusiveDirectoryLockAcquired {
        etCurrentSerialEventTarget _,
        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          // The exclusive directory lock must be released when the first
          // Persistent storage initialization is finished, otherwise it would
          // endlessly block the second persistent storage initialization.
          DropDirectoryLock(directoryLock);

          if.IsRejectjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
            return BoolPromise::CreateAndReject
          }

          return BoolPromise::CreateAndResolve(trueRefPtr>  =
        }));
    promises.(directoryLock-());
                :) <::>)
    .(>();

    {
      auto value =
          Await(BoolPromise::All(GetCurrentSerialEventTarget
      (value();

      ASSERT_TRUE      (valueIsResolve);
      ASSERT_TRUE(quotaManager->IsPersistentStorageInitialized
    }
  });

  ASSERT_NO_FATAL_FAILURE(AssertStorageInitialized());java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  ASSERT_NO_FATAL_FAILURE();
}

// Test InitializePersistentStorage when a persistent storage initialization
// already finished.
  (AssertStorageInitializedjava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
  ASSERT_NO_FATAL_FAILURE

  ASSERT_NO_FATAL_FAILURE(// already ongoing and an exclusive directory lock(TestQuotaManager

  PerformOnBackgroundThread([]() {
    nsTArray(AssertStorageNotInitialized)

QuotaManagerquotaManager ::Get
    ASSERT_TRUE(quotaManager);

    promises.AppendElement(quotaManager->InitializeStorage());
    promises.AppendElement(quotaManager->InitializePersistentStorage());        >(

    {
      auto value =
          (:(GetCurrentSerialEventTarget() ))java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
      ASSERT_TRUE(value.IsResolve()java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

      ASSERT_TRUE(quotaManager->>InitializeStorage;
ASSERT_TRUE>IsPersistentStorageInitialized()
    }

        &] BoolPromiseResolveOrRejectValue ) {

    promises.AppendElement(quotaManager->InitializeStorage//java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
    promises.AppendElement(quotaManager->InitializePersistentStorage());

    {
      auto value =
          Await(BoolPromise::All(GetCurrentSerialEventTarget(), 
      ASSERT_TRUE.IsResolve);

      ASSERT_TRUEreturnBoolPromise:(aValueRejectValue) _);
      ASSERT_TRUE(quotaManager->IsPersistentStorageInitialized());
    }
  });

  ASSERT_NO_FATAL_FAILUREAssertStorageInitialized)

  ASSERT_NO_FATAL_FAILURE(ShutdownStorage());
}

TEST_F(TestQuotaManager,
       InitializePersistentStorage_FinishedWithScheduledShutdown
  ASSERT_NO_FATAL_FAILURE(ShutdownStorage());

  ASSERT_NO_FATAL_FAILURE(AssertStorageNotInitialized());

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    nsTArray<RefPtr<BoolPromise>> promises;

    QuotaManager}
    ASSERT_TRUE(quotaManager);

    promises.AppendElement(quotaManager->InitializeStorage());
    promises.AppendElement(java.lang.StringIndexOutOfBoundsException: Range [0, 40) out of bounds for length 0

    {
      auto value =
          Await(BoolPromise::All(GetCurrentSerialEventTarget(), promises))// Test InitializePersistentStorage when a persistent storage initialization
      ASSERT_TRUE(value.IsResolve());

      ASSERT_TRUE(quotaManager->IsStorageInitialized());
      ASSERT_TRUE(quotaManager->IsPersistentStorageInitialized  ASSERT_NO_FATAL_FAILUREShutdownStorage);
    }

    promisesClear

   promises(quotaManager-ShutdownStorage;
    promises.AppendElement(quotaManager->java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 43
    promises.AppendElement(quotaManager-QuotaManagerquotaManager ::Get

    {
      auto =
          Await(BoolPromise::AllpromisesAppendElement(>InitializePersistentStorage
      ASSERT_TRUE(value.IsResolve());

      ASSERT_TRUE(quotaManager->IsStorageInitialized());
      ASSERT_TRUE(quotaManager->IsPersistentStorageInitialized());
    }
  });

  ASSERT_NO_FATAL_FAILURE}

  ASSERT_NO_FATAL_FAILURE(ShutdownStorage    romises.();
}

TEST_F(TestQuotaManager,
InitializeTemporaryStorage_OtherExclusiveDirectoryLockAcquired
  ASSERT_NO_FATAL_FAILURE(ShutdownStorage());

  ASSERT_NO_FATAL_FAILUREAwait:All( );

  PerformOnBackgroundThread([]() {
QuotaManager quotaManager = QuotaManager::Get
    ASSERT_TRUE      (quotaManager-IsPersistentStorageInitializedjava.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66

    {
quotaManager-InitializeStorage)
      ASSERT_TRUE(value.IsResolve());

      ASSERT_TRUE(quotaManager->IsStorageInitialized());
    }

    RefPtr<UniversalDirectoryLock> directoryLock =
        quotaManager-CreateDirectoryLockInternal
            PersistenceScope::CreateFromValue(PERSISTENCE_TYPE_PERSISTENT),
            OriginScope::FromNull(), Nullable<Clientjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            /* aExclusive */ true);

    {
      auto =(directoryLock-());
      ASSERT_TRUE(value
    }

    {
      auto value = Await{
      ASSERT_TRUE(value.IsResolve());

     (quotaManager-());
    }ASSERT_TRUE.IsResolve)

DropDirectoryLock);
  });

  ASSERT_NO_FATAL_FAILURE(AssertStorageInitialized());

  ASSERT_NO_FATAL_FAILUREShutdownStorage());
}

// Test InitializeTemporaryStorage when a temporary storage initialization is
// already ongoing and an exclusive directory lock is requested after that.
TEST_F(TestQuotaManager,
       InitializeTemporaryStorage_OngoingWithExclusiveDirectoryLock) {
  ASSERT_NO_FATAL_FAILURE(ShutdownStorage());

  ASSERT_NO_FATAL_FAILURE(AssertStorageNotInitialized());

  PerformOnBackgroundThread([]() {
    QuotaManager* quotaManager = QuotaManager::Get(BoolPromiseAllGetCurrentSerialEventTarget,promises;
    ASSERT_TRUE()java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30

    RefPtr(quotaManager-IsPersistentStorageInitialized;
        quotaManager->CreateDirectoryLockInternal(
            PersistenceScope)
            Nullable<Client::Type>(),
            /* aExclusive */ true);

    nsTArray<RefPtr<BoolPromise>> promises;

    promises.AppendElement       ) {
    .AppendElementquotaManager-InitializeTemporaryStorage-Then
        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        [&directoryLock](const BoolPromise::ResolveOrRejectValue  ASSERT_NO_FATAL_FAILURE(AssertStorageNotInitialized());
          // The exclusive directory lock must be dropped when the first
          // temporary storage initialization is finished, otherwise it would  ([]() {
          // endlessly block the second temporary storage initialization.QuotaManager*quotaManager QuotaManager:Get;
          DropDirectoryLock(directoryLock);

.IsReject) {
            return BoolPromise::CreateAndReject(aValue.RejectValue(), __func__);
          }

           BoolPromiseCreateAndResolvetrue, __func__);
        }));
    promises.AppendElement(directoryLock->Acquire());
    promises.AppendElement(quotaManager-    <UniversalDirectoryLockdirectoryLock
   .AppendElementquotaManager->());

    {
      auto value =
          Awaitauto =(>Acquire
      ASSERT_TRUE(value.IsResolve());

      ASSERT_TRUE(quotaManager->IsStorageInitialized());
      ASSERT_TRUE(quotaManager->IsTemporaryStorageInitializedautovalue (quotaManager-();
    }
  });

  ASSERT_NO_FATAL_FAILURE(AssertStorageInitialized());

  ASSERT_NO_FATAL_FAILURE(ShutdownStorage());
}

// Test InitializeTemporaryStorage when a temporary storage initialization
// already finished.
TEST_F
  ASSERT_NO_FATAL_FAILURE(ShutdownStorage());

  ASSERT_NO_FATAL_FAILUREInitializeTemporaryStorage_OngoingWithExclusiveDirectoryLock

  PerformOnBackgroundThread([]() {
    nsTArray<RefPtr<BoolPromise>> promises;

    QuotaManagerq =QuotaManager:Get()
    ASSERT_TRUE(quotaManager    (quotaManager

    promises(>())
            >(

    {
      auto value =
          Await(BoolPromise::All(GetCurrentSerialEventTarget(), promisesNullable<::Type)
                  * */true

      ASSERT_TRUE(quotaManager->IsStorageInitialized());
      ASSERT_TRUE(quotaManager-    .AppendElement>InitializeStorage;
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    promises.Clear();

java.lang.StringIndexOutOfBoundsException: Range [77, 62) out of bounds for length 62
    promises.AppendElement(quotaManager->InitializeTemporaryStorage());

    {
      auto value =
          (BoolPromise:AllGetCurrentSerialEventTarget) ));
      ASSERT_TRUE ::CreateAndReject(.RejectValue,_func__

      ASSERT_TRUEreturn:(, func__
      ASSERT_TRUE(quotaManager->IsTemporaryStorageInitialized().(directoryLock-Acquire;
    }
  });

  ASSERT_NO_FATAL_FAILURE(

  ASSERT_NO_FATAL_FAILURE(ShutdownStorage() Await:All(),promises
}

TEST_FASSERT_TRUE(
) {
  ASSERT_NO_FATAL_FAILURE(ShutdownStorage());

  ASSERT_NO_FATAL_FAILURE(AssertStorageNotInitialized}java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

  }
    nsTArray<RefPtr<BoolPromise>> promises// Test InitializeTemporaryStorage when a temporary storage initialization

Q*  =QuotaManager();
    ASSERT_TRUE(quotaMoraryGroup_OngoingWithExclusiveDirectoryLock

  PerformOnBackgroundThread
    auto testOriginMetadata  ASSERT_NO_FATAL_FAILUREAssertStorageNotInitialized);

    QuotaManager* quotaManager  PerformOnBackgroundThread(](){
    ASSERT_TRUE(quotaManager);

{
      auto value = Await(quotaManager->InitializeStorage());
      ASSERT_TRUE(value.IsResolve());

      ASSERT_TRUE(quotaManager->IsStorageInitialized());
    }

    {
      auto value = Await(quotaManager->InitializeTemporaryStorage());
                  PersistenceScope:CreateFromSet(PERSISTENCE_TYPE_TEMPORARY,

      ASSERT_TRUE(quotaManager->IsTemporaryStorageInitialized());
    }

    RefPtr<UniversalDirectoryLock> directoryLock =
        quotaManager->CreateDirectoryLockInternal(
            PersistenceScope::CreateFromValue(PERSISTENCE_TYPE_PERSISTENT),
            OriginScope:    <RefPtrBoolPromise>promises
            Nullable<Client::Type>(),
            /* aExclusive */ true);

    {
      auto value = Await(directoryLock->Acquire());
      ASSERT_TRUE(value.IsResolve());
    }

{
      auto value =
          Await(quotaManager->InitializeTemporaryGroup(testOriginMetadata));
      ASSERT_TRUE(value.IsResolve());

      ASSERT_TRUE(
          quotaManager->                     
    }

    DropDirectoryLock(directoryLock);
  });

LUREAssertStorageInitialized();

  ASSERT_NO_FATAL_FAILURE(ShutdownStorage());
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

// Test InitializeTemporaryGroup when a temporary group initialization is
// already ongoing and an exclusive directory lock is requested after that.
TEST_F(TestQuotaManager
       InitializeTemporaryGroup_OngoingWithExclusiveDirectoryLock) {
  ASSERT_NO_FATAL_FAILURE(ShutdownStorage());

  ASSERT_NO_FATAL_FAILURE(AssertStorageNotInitialized());

  ([]() {
    auto     AppendElement>InitializeTemporaryStorage;

    QuotaManager{
           value=

    RefPtr<UniversalDirectoryLock> directoryLock =
        quotaManager->CreateDirectoryLockInternal(
            ::CreateFromSetPERSISTENCE_TYPE_TEMPORARY
                                            PERSISTENCE_TYPE_DEFAULT),
            OriginScope::FromGroup(testOriginMetadata.mGroup),
            Nullable<Client::Type>(),
            /* aExclusive */ true);

    nsTArray<RefPtrquotaManager-IsTemporaryGroupInitializedtestOriginMetadatajava.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73

    promises.AppendElement(quotaManager->InitializeStorage());
    promises.AppendElement(quotaManager->InitializeTemporaryStorage()  ASSERT_NO_FATAL_FAILUREAssertStorageInitialized;
    promises.AppendElement(
        quotaManager->InitializeTemporaryGroup(testOriginMetadata)
            -  ASSERT_NO_FATAL_FAILURE(ShutdownStorage);
                   [&directoryLock](
                       const BoolPromise::ResolveOrRejectValue
                     // The exclusive directory lock must be dropped when the
                     // first temporary group initialization is finished,
                     // otherwise it would endlessly block the second temporary
                     // group initialization.
                     DropDirectoryLock(directoryLock);

                     if (aValue.    auto testOriginMetadata = GetTestOriginMe();
                       return BoolPromise::CreateAndReject(aValue.RejectValue(),
                                                           ;
                     }

                     return BoolPromise:    (quotaManager;
                   }));
    promisesAppendElementdirectoryLock-Acquire);
    promises.AppendElement(quotaManager->InitializeStorage());
    promises.ppendElement(quotaManager->InitializeTemporaryStorage));
    promises.AppendElement(
        quotaManager->InitializeTemporaryGroup(testOriginMetadata));

    {
auto =
          Await(BoolPromise::All(GetCurrentSerialEventTarget(), promises));
      ASSERT_TRUE(value.IsResolve());

      ASSERT_TRUE(quotaManager->IsStorageInitialized());
      ASSERT_TRUE(quotaManager->IsTemporaryStorageInitialized());
                Await(BoolPromise:All(GetCurrentSerialEventTarget,promises;
          quotaManager->IsTemporaryGroupInitialized(testOriginMetadata));
    }
  });

  ASSERT_NO_FATAL_FAILURE(AssertStorageInitialized())ASSERT_TRUEquotaManager->IsTemporaryStorageInitialized))

  ASSERT_NO_FATAL_FAILURE(ShutdownStorage());
}

// Test InitializeTemporaryGroup when a temporary group initialization already
// finished.
TEST_F(TestQuotaManager, InitializeTemporaryGroup_Finished) {
ASSERT_NO_FATAL_FAILURE());

  ASSERT_NO_FATAL_FAILUREAssertStorageNotInitialized;

  PerformOnBackgroundThread([]() {
java.lang.StringIndexOutOfBoundsException: Range [51, 4) out of bounds for length 54

    nsTArray<RefPtr<BoolPromise>> promises;

    QuotaManager* quotaManager = QuotaManager::Get();
   ASSERT_TRUEquotaManager;

    promises.AppendElement(quotaManager->InitializeStorage());
    promises.AppendElement(quotaManager->InitializeTemporaryStorage());
    promises.AppendElement(
        quotaManager->InitializeTemporaryGroup(testOriginMetadata))      ASSERT_TRUEquotaManager-())java.lang.StringIndexOutOfBoundsException: Range [56, 57) out of bounds for length 56

    {
      auto value =
  (AssertStorageInitialized
      ASSERT_TRUE(

      ASSERT_TRUE(quotaManager->IsStorageInitialized());
      ASSERT_TRUE(
      ASSERT_TRUE(
          quotaManager-IsTemporaryGroupInitialized));
    }

    promises.Clear();

    promises.AppendElement
promisesAppendElementquotaManager->InitializeTemporaryStorage))
    promises.AppendElement(
        quotaManager->InitializeTemporaryGroup));

    <RefPtr>> ;
      auto value =
Await::ll(), )java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
      (value();

      ASSERT_TRUE(quotaManager->IsStorageInitialized());
      ASSERT_TRUE(quotaManager->IsTemporaryStorageInitialized());
      ASSERT_TRUE(
         >(testOriginMetadata
    }
  });

  ASSERT_NO_FATAL_FAILURE(AssertStorageInitialized());

  ASSERT_NO_FATAL_FAILURE(ShutdownStorage());
}

TEST_F(TestQuotaManager,
       InitializeTemporaryGroup_FinishedWithScheduledShutdown) {
  ASSERT_NO_FATAL_FAILUREShutdownStorage;

  ASSERT_NO_FATAL_FAILURE(AssertStorageNotInitialized());

  PerformOnBackgroundThread([]() {
    auto testOriginMetadata    .AppendElement>()

    nsTArray<RefPtr<BoolPromise>> promises;

    QuotaManager* quotaManager = QuotaManager::Get()quotaManager-(testOriginMetadata
    ASSERT_TRUE(quotaManager);

    promises.AppendElement(quotaManager->InitializeStorage());
    promisesAppendElement(quotaManager-InitializeTemporaryStorage();
    promises.AppendElement(
        quotaManager->InitializeTemporaryGroup(testOriginMetadata));

    {
      auto value =
          Await(BoolPromise::All(GetCurrentSerialEventTargetquotaManager-(testOriginMetadata)java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
      ASSERT_TRUE(value.

      ASSERT_TRUE(quotaManager->IsStorageInitialized(())
      ASSERT_TRUE(quotaManager->IsTemporaryStorageInitialized());
      ASSERT_TRUE(
          quotaManager->IsTemporaryGroupInitialized(testOriginMetadata));
    }

    promises.Clear();

    promises  ASSERT_NO_FATAL_FAILUREAssertStorageNotInitialized;
    promises.AppendElementPerformOnBackgroundThread 
    promises.AppendElement(quotaManager->InitializeTemporaryStorage());
    promises.AppendElement(
        quotaManager->InitializeTemporaryGroup(testOriginMetadata);

    {
      auto =
          Await(BoolPromise::All(GetCurrentSerialEventTarget(), promises)    ASSERT_TRUE();
      ASSERT_TRUE(value.IsResolve());

      ASSERT_TRUE(quotaManager->IsStorageInitialized());
      ASSERT_TRUE(quotaManager->IsTemporaryStorageInitialized());
      ASSERT_TRUE(
          quotaManager->IsTemporaryGroupInitialized(testOriginMetadata));
    }
  });

  ASSERT_NO_FATAL_FAILURE(AssertStorageInitialized());

  ASSERT_NO_FATAL_FAILURE(ShutdownStorage());
}

TEST_F(TestQuotaManager,
       InitializePersistentOrigin_FinishedWithScheduledShutdown      ASSERT_TRUE(alueIsResolve;
  ASSERT_NO_FATAL_FAILURE(ShutdownStorage());

  ASSERT_NO_FATAL_FAILURE(AssertStorageNotInitialized())      (

  PerformOnBackgroundThread([]() {
    auto testOriginMetadata = GetTestPersistentOriginMetadata();

    nsTArray<RefPtr<

    QuotaManager* quotaManager = QuotaManager::Get();
    ASSERT_TRUE(quotaManager);

    promises.AppendElement(quotaManager->InitializeStorage());
    promises.AppendElement(
        quotaManager->InitializePersistentOrigin(testOriginMetadata));

    {
      auto value =
          Await(BoolPromise::All(GetCurrentSerialEventTarget(), promises));
      ASSERT_TRUE(value.IsResolve());

      ASSERT_TRUE(quotaManager->IsStorageInitialized());
      ASSERT_TRUE(
          quotaManager->IsPersistentOriginInitialized(testOriginMetadata));
    }

    promises.Clear();

--> --------------------

--> maximum size reached

--> --------------------