/// <summary>
/// Inits Cognito Sync with unauthenticated user credentials.
/// </summary>
public void InitWithoutFacebook()
{
enabled = true;
// Enabling Logs
//AmazonLogging.EnableSDKLogging = true;
// CognitoAWSCredentials is recommended in the place of Developer credentials{accessKey,secretKey} for reasons of security best practices
// CognitoAWSCredentials uses the CognitoIdentityProvider & provides temporary scoped AWS credentials from AssumeRoleWithWebIdentity
// ref: http://mobile.awsblog.com/post/TxR1UCU80YEJJZ/Using-the-Amazon-Cognito-Credentials-Provider
// Ref: http://docs.aws.amazon.com/mobile/sdkforandroid/developerguide/cognito-auth.html#create-an-identity-pool
// for setting up Cognito Identity Pools, can you use the sample code for .NET SDK
try {
credentials = new CachingCognitoAWSCredentials();
} catch (Exception ex) {
Debug.LogException(ex);
return;
}
// DefaultCognitoSyncManager is a high level CognitoSync Client which handles all Sync operations at a Dataset level.
// Additionally, it also provides local storage of the Datasets which can be later Synchronized with the cloud(CognitoSync service)
// This feature allows the user to continue working w/o internet access and sync with CognitoSync whenever possible
syncManager = new DefaultCognitoSyncManager(credentials, new AmazonCognitoSyncConfig {
RegionEndpoint = RegionEndpoint.USEast1
});
initializationPending = true;
}
/*
* Initialization.
*/
public static void Initialize(string poolId)
{
if (Initializing)
{
_log.Error("Already initializing");
return;
}
if (Initialized)
{
_log.Error("Already initialized");
return;
}
_log.Debug("Initializing");
Initializing = true;
_poolId = poolId;
_instance = new GameObject("BitszerAuctionHouse").AddComponent <AuctionHouse>();
UnityInitializer.AttachToGameObject(_instance.gameObject);
AWSConfigs.HttpClient = AWSConfigs.HttpClientOption.UnityWebRequest;
AWSConfigs.LoggingConfig.LogTo = LoggingOptions.None;
_credentials = new CognitoAWSCredentials(_poolId, RegionEndpoint);
_credentials.GetIdentityIdAsync(OnIdentityReceived);
_syncManager = new CognitoSyncManager(_credentials, RegionEndpoint);
}
private void Init(string authProvider, string accessToken)
{
enabled = true;
if (string.IsNullOrEmpty(IDENTITY_POOL_ID))
{
throw new NotSupportedException("Please setup your the identity pool id in SceneController");
}
//Enable Logs
AmazonLogging.Level = AmazonLogging.LoggingLevel.DEBUG;
//Create a Credentials provider that uses Cognito Identity
credentials = new CognitoAWSCredentials(IDENTITY_POOL_ID, ENDPOINT);
//If fbAccesToken is set, we can use Cognito's authenticated identities
if (accessToken != null)
{
credentials.AddLogin(authProvider, accessToken);
}
syncManager = new DefaultCognitoSyncManager(credentials, new AmazonCognitoSyncConfig {
RegionEndpoint = ENDPOINT
});
InitializeCharactersDataset();
}
/// <summary>
/// Test case: Add and synchronize a dataset, then wipe data. Wiping data (while
/// using unauthorized credentials) should wipe the dataset and the identity,
/// so that the information in the dataset should no longer be retrievable.
/// Check that the dataset is no longer in local memory and that syncing a
/// dataset with the same record key does not cause a conflict.
/// </summary>
//[TestMethod]
//[TestCategory("SyncManager")]
public void WipeDataTest()
{
string failureMessage = string.Empty;
CognitoSyncManager syncManager = new CognitoSyncManager(UnAuthCredentials);
syncManager.WipeData(false);
Dataset d = syncManager.OpenOrCreateDataset("testDataset5");
d.Put("testKey", "testValue");
d.OnSyncConflict += delegate(Dataset dataset, List <SyncConflict> conflicts)
{
failureMessage += "Expecting SyncSuccess instead of SyncConflict\n";
return(false);
};
d.OnSyncFailure += delegate(object sender, SyncFailureEventArgs e)
{
failureMessage += "Expecting SyncSuccess instead of SyncFailure\n";
};
d.OnSyncSuccess += delegate(object sender, SyncSuccessEventArgs e)
{
syncManager.WipeData();
Dataset d2 = syncManager.OpenOrCreateDataset("testDataset5");
if (d2.Records.Count != 0)
{
failureMessage += "Expecting dataset to be empty due to local data wipe.\n";
}
d2.Put("testKey", "newTestValue");
d2.OnSyncConflict += delegate(Dataset dataset, List <SyncConflict> conflicts)
{
failureMessage += "Expecting SyncSuccess instead of SyncConflict\n";
return(false);
};
d2.OnSyncFailure += delegate(object sender2, SyncFailureEventArgs e2)
{
failureMessage += "Expecting SyncSuccess instead of SyncFailure\n";
};
d2.OnSyncSuccess += delegate(object sender2, SyncSuccessEventArgs e2)
{
if (d2.Get("testKey") != "newTestValue")
{
failureMessage += "Value for key 'testKey' should be 'newTestValue'\n";
}
};
#if BCL35
d2.Synchronize();
#else
RunAsSync(async() => await d2.SynchronizeAsync());
#endif
};
#if BCL35
d.Synchronize();
#else
RunAsSync(async() => await d.SynchronizeAsync());
#endif
if (!string.IsNullOrEmpty(failureMessage))
{
Assert.Fail(failureMessage);
}
}
public static void init()
{
String identityPoolId = "YOUR_IDENTITY_POOL_ID"; //Set your Identity Pool here
Amazon.RegionEndpoint region = Amazon.RegionEndpoint.USEast1;
if (String.IsNullOrEmpty(identityPoolId))
{
throw new Exception("You need to set up an identity pool in CognitoSyncClientManager.cs");
}
// CognitoAWSCredentials is recommended in the place of Developer credentials{accessKey,secretKey} for reasons of security best practices
// CognitoAWSCredentials uses the CognitoIdentityProvider & provides temporary scoped AWS credentials from AssumeRoleWithWebIdentity
// ref: http://mobile.awsblog.com/post/TxR1UCU80YEJJZ/Using-the-Amazon-Cognito-Credentials-Provider
#if DEVELOPER_AUTHENTICATED_IDENTITIES
// or to use developer authenticated identities
CognitoAWSCredentials _credentials = new CognitoAWSCredentials(new ExampleIdentityProvider());
#else
// Ref: http://docs.aws.amazon.com/mobile/sdkforandroid/developerguide/cognito-auth.html#create-an-identity-pool
// for setting up Cognito Identity Pools, can you use the sample code for .NET SDK
_credentials = new CognitoAWSCredentials(identityPoolId, region);
#endif
// DefaultCognitoSyncManager is a high level CognitoSync Client which handles all Sync operations at a Dataset level.
// Additionally, it also provides local storage of the Datasets which can be later Synchronized with the cloud(CognitoSync service)
// This feature allows the user to continue working w/o internet access and sync with CognitoSync whenever possible
_syncManager = new DefaultCognitoSyncManager(_credentials, new AmazonCognitoSyncConfig {
RegionEndpoint = region
});
}
private CognitoSyncViewModel()
{
credentials = new CognitoAWSCredentials(Constants.AWS_IDENTITY_POOL_ID, RegionEndpoint.EUWest1);
syncManager = new CognitoSyncManager(credentials, new AmazonCognitoSyncConfig {
RegionEndpoint = RegionEndpoint.EUWest1
});
datasets = new Dictionary <string, Dataset> ();
}
/// <summary>
/// Test case: Produce a conflict and check that SyncConflict is triggered.
/// Also check that by returning false in SyncConflict, the Synchronize operation
/// is aborted and nothing else gets called.
/// </summary>
//[TestMethod]
//[TestCategory("SyncManager")]
public void ConflictTest()
{
string failureMessage = string.Empty;
using (CognitoSyncManager syncManager = new CognitoSyncManager(UnAuthCredentials))
{
syncManager.WipeData(false);
using (Dataset d = syncManager.OpenOrCreateDataset("testDataset3"))
{
d.Put("testKey3", "the initial value");
d.OnSyncSuccess += delegate(object sender, SyncSuccessEventArgs e)
{
d.ClearAllDelegates();
syncManager.WipeData(false);
using (Dataset d2 = syncManager.OpenOrCreateDataset("testDataset3"))
{
bool conflictTriggered = false;
d2.Put("testKey3", "a different value");
d2.OnSyncConflict += delegate(Dataset dataset, List <SyncConflict> conflicts)
{
conflictTriggered = true;
return(false);
};
d2.OnSyncSuccess += delegate(object sender4, SyncSuccessEventArgs e4)
{
failureMessage += "Expecting OnSyncConflict instead of OnSyncSuccess\n";
};
d2.OnSyncFailure += delegate(object sender4, SyncFailureEventArgs e4)
{
if (!conflictTriggered)
{
failureMessage += "Expecting OnSyncConflict instead of OnSyncFailure\n";
}
};
#if BCL35
d2.Synchronize();
#else
RunAsSync(async() => await d2.SynchronizeAsync());
#endif
}
};
d.OnSyncFailure += delegate(object sender, SyncFailureEventArgs e)
{
failureMessage += "Expecting OnSyncSuccess instead of OnSyncFailure\n";
};
#if BCL35
d.Synchronize();
#else
RunAsSync(async() => await d.SynchronizeAsync());
#endif
}
}
if (!string.IsNullOrEmpty(failureMessage))
{
Assert.Fail(failureMessage);
}
}
public void RemoveEntryTest()
{
AutoResetEvent ars = new AutoResetEvent(false);
string failureMessage = string.Empty;
CognitoSyncManager syncManager = null;
AutoResetEvent mainThreadArs = new AutoResetEvent(false);
Amazon.Runtime.Internal.UnityRequestQueue.Instance.ExecuteOnMainThread(() =>
{
syncManager = new CognitoSyncManager(UnAuthCredentials, TestRunner.RegionEndpoint);
mainThreadArs.Set();
});
mainThreadArs.WaitOne();
syncManager.WipeData(false);
Dataset d = syncManager.OpenOrCreateDataset("testRemoveDataset");
long originalCount = d.Metadata.RecordCount;
d.Put("testKey", "testValue");
d.OnSyncConflict += delegate(Dataset dataset, List <SyncConflict> conflicts)
{
failureMessage += "Expecting SyncSuccess instead of SyncConflict\n";
return(false);
};
d.OnSyncFailure += delegate(object sender, SyncFailureEventArgs e)
{
failureMessage += "Expecting SyncSuccess instead of SyncFailure\n";
ars.Set();
};
d.OnSyncSuccess += delegate(object sender, SyncSuccessEventArgs e)
{
ars.Set();
};
d.SynchronizeAsync(new AsyncOptions {
ExecuteCallbackOnMainThread = false
});
ars.WaitOne();
Utils.AssertStringIsNullOrEmpty(failureMessage);
d.Remove("testKey");
d.SynchronizeAsync(new AsyncOptions {
ExecuteCallbackOnMainThread = false
});
ars.WaitOne();
if (d.Metadata.RecordCount != originalCount)
{
failureMessage += "d.Metadata.RecordCount != originalCount\n";
}
syncManager.Dispose();
d.Dispose();
Utils.AssertStringIsNullOrEmpty(failureMessage);
}
void Start()
{
UnityInitializer.AttachToGameObject(this.gameObject);
//Remove if you want to build on an IOS device.
AWSConfigs.LoggingConfig.LogTo = LoggingOptions.UnityLogger;
credentials = new CognitoAWSCredentials("" //Put your own identity pool id here.
, RegionEndpoint.USEast1);
syncManager = new CognitoSyncManager(credentials, RegionEndpoint.USEast1);
playerInfo = syncManager.OpenOrCreateDataset("playerInfo");
playerInfo.OnSyncSuccess += SyncSuccessCallback;
UpdateInformation();
}
// Start is called before the first frame update
void Start()
{
UnityInitializer.AttachToGameObject(this.gameObject);
AWSConfigs.HttpClient = AWSConfigs.HttpClientOption.UnityWebRequest;
credentials = new CognitoAWSCredentials(
"us-east-2:cd8a1e15-89bb-44b1-95b4-9225913c86b6",
RegionEndpoint.USEast2
);
manager = new CognitoSyncManager(credentials, RegionEndpoint.USEast2);
playerInfo = manager.OpenOrCreateDataset("playerInfo");
playerInfo.OnSyncSuccess += PlayerInfo_OnSyncSuccess;
UpdateInformation();
}
//[TestMethod]
//[TestCategory("SyncManager")]
public void RemoveEntryTest()
{
string failureMessage = string.Empty;
using (var syncManager = new CognitoSyncManager(UnAuthCredentials))
{
syncManager.WipeData(false);
Dataset d = syncManager.OpenOrCreateDataset("testRemoveDataset");
long originalCount = d.Metadata.RecordCount;
d.Put("testKey", "testValue");
d.OnSyncConflict += delegate(Dataset dataset, List <SyncConflict> conflicts)
{
failureMessage += "Expecting SyncSuccess instead of SyncConflict\n";
return(false);
};
d.OnSyncFailure += delegate(object sender, SyncFailureEventArgs e)
{
failureMessage += "Expecting SyncSuccess instead of SyncFailure\n";
};
#if BCL35
d.Synchronize();
#else
RunAsSync(async() => await d.SynchronizeAsync());
#endif
if (!string.IsNullOrEmpty(failureMessage))
{
Assert.Fail(failureMessage);
}
d.Remove("testKey");
#if BCL35
d.Synchronize();
#else
RunAsSync(async() => await d.SynchronizeAsync());
#endif
if (d.Metadata.RecordCount != originalCount)
{
failureMessage += "d.Metadata.RecordCount != originalCount\n";
}
d.Dispose();
if (!string.IsNullOrEmpty(failureMessage))
{
Assert.Fail(failureMessage);
}
}
}
//[TestMethod]
//[TestCategory("SyncManager")]
public void DatasetLocalStorageTest()
{
{
using (CognitoSyncManager syncManager = new CognitoSyncManager(UnAuthCredentials))
{
syncManager.WipeData(false);
Dataset d = syncManager.OpenOrCreateDataset("testDataset");
d.Put("testKey", "testValue");
}
}
{
using (CognitoSyncManager syncManager = new CognitoSyncManager(UnAuthCredentials))
{
Dataset d = syncManager.OpenOrCreateDataset("testDataset");
Assert.AreEqual("testValue", d.Get("testKey"));
}
}
}
// Use this for initialization
void Start()
{
// Enabling Logs
// AmazonLogging.EnableSDKLogging = true;
difficultyLevels = new string[] { "Expert", "Medium", "Easy" };
try
{
CognitoSyncClientManager.init();
syncManager = CognitoSyncClientManager.CognitoSyncManagerInstance;
}
catch (Exception ex)
{
statusMessage = "Please setup the Cognito credentials for the AWSPrefab in the scene";
Debug.LogException(ex);
return;
}
// Loading the datasets
playerInfo = syncManager.OpenOrCreateDataset("PlayerInfo");
playerSettings = syncManager.OpenOrCreateDataset("PlayerSettings");
// fetching locally stored data
alias = string.IsNullOrEmpty(playerInfo.Get("alias")) ? "Enter ur alias" : playerInfo.Get("alias");
playerName = string.IsNullOrEmpty(playerInfo.Get("playerName")) ? "Enter ur fullName" : playerInfo.Get("playerName");
selectedDifficultyLevel = string.IsNullOrEmpty(playerSettings.Get("selectedDifficultyLevel")) ? 0 : int.Parse(playerSettings.Get("selectedDifficultyLevel"));
statusMessage = "Welcome ..";
// when ds.Synchronize() is called the localDataset is merged with the remoteDataset
// OnDatasetDeleted, OnDatasetMerged, OnDatasetSuccess, the corresponding callback is fired.
// The developer has the freedom of handling these events needed for the Dataset
playerInfo.OnSyncSuccess += this.HandleSyncSuccess; // OnSyncSucess uses events/delegates pattern
playerInfo.OnSyncFailure += this.HandleSyncFailure; // OnSyncFailure uses events/delegates pattern
playerInfo.OnSyncConflict = this.HandleSyncConflict;
playerInfo.OnDatasetMerged = this.HandleDatasetMerged;
playerInfo.OnDatasetDeleted = this.HandleDatasetDeleted;
// playerSettings Dataset shows the use of default callback for syncManager
// The OnSyncConflict event defaults to last writer wins policy
// OnSyncSucess, OnSyncFailure, OnDatasetMerged events are ignored
// OnDatasetDeleted defaults to false
}
public static void init()
{
// CognitoAWSCredentials is recommended in the place of Developer credentials{accessKey,secretKey} for reasons of security best practices
// CognitoAWSCredentials uses the CognitoIdentityProvider & provides temporary scoped AWS credentials from AssumeRoleWithWebIdentity
// ref: http://mobile.awsblog.com/post/TxR1UCU80YEJJZ/Using-the-Amazon-Cognito-Credentials-Provider
#if DEVELOPER_AUTHENTICATED_IDENTITIES
// or to use developer authenticated identities
CachingCognitoAWSCredentials _credentials = new CachingCognitoAWSCredentials(AmazonInitializer.DefaultUnAuthRole, AmazonInitializer.DefaultAuthRole,
new ExampleIdentityProvider(), new AmazonSecurityTokenServiceClient(AmazonInitializer.CognitoRegionEndpoint));
#else
// Ref: http://docs.aws.amazon.com/mobile/sdkforandroid/developerguide/cognito-auth.html#create-an-identity-pool
// for setting up Cognito Identity Pools, can you use the sample code for .NET SDK
_credentials = new CachingCognitoAWSCredentials();
#endif
// DefaultCognitoSyncManager is a high level CognitoSync Client which handles all Sync operations at a Dataset level.
// Additionally, it also provides local storage of the Datasets which can be later Synchronized with the cloud(CognitoSync service)
// This feature allows the user to continue working w/o internet access and sync with CognitoSync whenever possible
_syncManager = new DefaultCognitoSyncManager(_credentials, new AmazonCognitoSyncConfig {
RegionEndpoint = AmazonInitializer.CognitoRegionEndpoint
});
}
// Start is called before the first frame update
void Start()
{
Debug.Log("Login Client Started");
AWSConfigs.HttpClient = AWSConfigs.HttpClientOption.UnityWebRequest;
awsCredentials = new CognitoAWSCredentials(
"ap-south-1:0edf52b9-63a5-4fbe-9299-aa9c9413aa2d", // Identity pool ID
RegionEndpoint.APSouth1 // Region
);
syncManager = new CognitoSyncManager(awsCredentials, RegionEndpoint.APSouth1);
dbClient = new AmazonDynamoDBClient(awsCredentials, RegionEndpoint.APSouth1);
dbContext = new DynamoDBContext(dbClient);
playerInfo = syncManager.OpenOrCreateDataset("playerInfo");
playerInfo.OnSyncSuccess += SyncSuccessCallBack;
playerInfo.OnSyncFailure += HandleSyncFailure;
fbandcsInitiated = fbandcsInitiated + 1;
PlayGamesClientConfiguration config = new PlayGamesClientConfiguration.Builder().RequestEmail().RequestIdToken().RequestServerAuthCode(false).Build();
PlayGamesPlatform.InitializeInstance(config);
PlayGamesPlatform.DebugLogEnabled = true;
PlayGamesPlatform.Activate();
//Social.localUser.Authenticate(GoogleLoginCallback);
}
public void DatasetLocalStorageTest()
{
{
CognitoSyncManager syncManager = null;
AutoResetEvent mainThreadArs = new AutoResetEvent(false);
Amazon.Runtime.Internal.UnityRequestQueue.Instance.ExecuteOnMainThread(() =>
{
syncManager = new CognitoSyncManager(UnAuthCredentials, TestRunner.RegionEndpoint);
mainThreadArs.Set();
});
mainThreadArs.WaitOne();
syncManager.WipeData(false);
Dataset d = syncManager.OpenOrCreateDataset("testDataset");
d.Put("testKey", "testValue");
syncManager.Dispose();
}
{
CognitoSyncManager syncManager = null;
AutoResetEvent mainThreadArs = new AutoResetEvent(false);
Amazon.Runtime.Internal.UnityRequestQueue.Instance.ExecuteOnMainThread(() =>
{
syncManager = new CognitoSyncManager(UnAuthCredentials, TestRunner.RegionEndpoint);
mainThreadArs.Set();
});
mainThreadArs.WaitOne();
try
{
Dataset d = syncManager.OpenOrCreateDataset("testDataset");
Utils.AssertTrue("testValue" == d.Get("testKey"));
}
finally
{
syncManager.Dispose();
}
}
}
public void MergeTest()
{
var epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
string uniqueName = ((DateTime.UtcNow - epoch).TotalSeconds).ToString();
string uniqueName2 = uniqueName + "_";
UnAuthCredentials.Clear();
AutoResetEvent ars = new AutoResetEvent(false);
string failureMessage = string.Empty;
CognitoSyncManager sm1 = null;
AutoResetEvent mainThreadArs = new AutoResetEvent(false);
Amazon.Runtime.Internal.UnityRequestQueue.Instance.ExecuteOnMainThread(() =>
{
sm1 = new CognitoSyncManager(AuthCredentials, TestRunner.RegionEndpoint);
mainThreadArs.Set();
});
mainThreadArs.WaitOne();
sm1.WipeData(false);
Thread.Sleep(2000);
Dataset d = sm1.OpenOrCreateDataset("test");
d.Put(uniqueName, uniqueName);
d.OnSyncSuccess += delegate(object s1, SyncSuccessEventArgs e1)
{
ars.Set();
};
d.OnSyncFailure += delegate(object s, SyncFailureEventArgs e)
{
failureMessage += string.Format("Not expecting OnSyncFailure Got exception {0}\n", e.Exception.Message);
ars.Set();
};
d.OnSyncConflict += (Dataset dataset, List <SyncConflict> syncConflicts) =>
{
failureMessage += "Not expecting OnSyncConflict\n";
return(false);
};
d.OnDatasetDeleted += (Dataset dataset) =>
{
failureMessage += "Not expecting OnDatasetDeleted\n";
return(false);
};
d.OnDatasetMerged += (Dataset dataset, List <string> datasetNames) =>
{
failureMessage += "Not expecting OnDatasetMerged\n";
return(false);
};
d.SynchronizeAsync(new AsyncOptions {
ExecuteCallbackOnMainThread = false
});
ars.WaitOne();
d.Dispose();
sm1.Dispose();
Utils.AssertStringIsNullOrEmpty(failureMessage);
UnAuthCredentials.Clear();
CognitoSyncManager sm2 = null;
Amazon.Runtime.Internal.UnityRequestQueue.Instance.ExecuteOnMainThread(() =>
{
sm2 = new CognitoSyncManager(UnAuthCredentials, TestRunner.RegionEndpoint);
mainThreadArs.Set();
});
mainThreadArs.WaitOne();
Thread.Sleep(2000);
Dataset d2 = sm2.OpenOrCreateDataset("test");
d2.Put(uniqueName2, uniqueName2);
d2.OnSyncSuccess += delegate(object s2, SyncSuccessEventArgs e2)
{
ars.Set();
};
d2.OnSyncFailure += (object sender, SyncFailureEventArgs e) =>
{
failureMessage += string.Format("Not expecting OnSyncFailure Got exception {0}\n", e.Exception.Message);
ars.Set();
};
d2.OnSyncConflict += (Dataset dataset, List <SyncConflict> conflicts) =>
{
failureMessage += "Not expecting OnSyncConflict\n";
return(false);
};
d2.OnDatasetDeleted += (Dataset dataset) =>
{
failureMessage += "Not expecting OnDatasetDeleted\n";
return(false);
};
d2.OnDatasetMerged += (Dataset dataset, List <string> datasetNames) =>
{
failureMessage += "Not expecting OnDatasetMerged\n";
return(false);
};
d2.SynchronizeAsync(new AsyncOptions {
ExecuteCallbackOnMainThread = false
});
ars.WaitOne();
d2.Dispose();
sm2.Dispose();
Utils.AssertStringIsNullOrEmpty(failureMessage);
AuthCredentials.Clear();
UnAuthCredentials.Clear();
CognitoSyncManager sm3 = null;
Amazon.Runtime.Internal.UnityRequestQueue.Instance.ExecuteOnMainThread(() =>
{
sm3 = new CognitoSyncManager(AuthCredentials, TestRunner.RegionEndpoint);
mainThreadArs.Set();
});
mainThreadArs.WaitOne();
Thread.Sleep(2000);
Dataset d3 = sm3.OpenOrCreateDataset("test");
bool mergeTriggered = false;
d3.OnSyncSuccess += (object sender, SyncSuccessEventArgs e) =>
{
if (!mergeTriggered)
{
failureMessage += "Expecting DatasetMerged instead of OnSyncSuccess\n";
}
ars.Set();
};
d3.OnSyncFailure += (object sender, SyncFailureEventArgs e) =>
{
failureMessage += string.Format("Not expecting OnSyncFailure Got exception {0}\n", e.Exception.Message);
ars.Set();
};
d3.OnSyncConflict += (Dataset dataset, List <SyncConflict> syncConflicts) =>
{
failureMessage += "Not expecting OnSyncConflict\n";
return(false);
};
d3.OnDatasetDeleted += (Dataset dataset) =>
{
failureMessage += "Not expecting OnDatasetDeleted\n";
return(false);
};
d3.OnDatasetMerged += delegate(Dataset ds, List <string> datasetNames)
{
mergeTriggered = true;
return(true);
};
d3.SynchronizeAsync(new AsyncOptions {
ExecuteCallbackOnMainThread = false
});
ars.WaitOne();
Utils.AssertStringIsNullOrEmpty(failureMessage);
}
// <summary>
/// Test case: Store a value in a dataset and sync it. Wipe all local data.
/// After synchronizing the dataset we should have our stored value back.
/// </summary>
//[TestMethod]
//[TestCategory("SyncManager")]
public void DatasetCloudStorageTest()
{
string failureMessage = string.Empty;
using (CognitoSyncManager syncManager = new CognitoSyncManager(UnAuthCredentials))
{
syncManager.WipeData(false);
Thread.Sleep(2000);
using (Dataset d = syncManager.OpenOrCreateDataset("testDataset2"))
{
d.Put("key", "he who must not be named");
d.OnSyncSuccess += delegate(object sender, SyncSuccessEventArgs e)
{
d.ClearAllDelegates();
string erasedValue = d.Get("key");
syncManager.WipeData(false);
d.OnSyncSuccess += delegate(object sender2, SyncSuccessEventArgs e2)
{
string restoredValues = d.Get("key");
if (erasedValue == null)
{
failureMessage += "erasedValue should not be null\n";
}
if (restoredValues == null)
{
failureMessage += "restoredValues should not be null\n";
}
if (erasedValue != restoredValues)
{
failureMessage += "erasedValue should equal restoredValues\n";
}
};
d.OnSyncFailure += delegate(object sender2, SyncFailureEventArgs e2)
{
failureMessage += "sync failed\n";
};
#if BCL35
d.Synchronize();
#else
RunAsSync(async() => await d.SynchronizeAsync());
#endif
};
d.OnSyncFailure += delegate(object sender, SyncFailureEventArgs e)
{
failureMessage += "sync failed\n";
};
d.OnSyncConflict += delegate(Dataset dataset, List <SyncConflict> conflicts)
{
failureMessage += "Expected SyncSuccess instead of SyncConflict\n";
return(false);
};
d.OnDatasetMerged += (Dataset dataset, List <string> datasetNames) =>
{
failureMessage += "Did not expect DatasetMerged\n";
return(false);
};
d.OnDatasetDeleted += (Dataset dataset) =>
{
failureMessage += "Did not expect DatasetDeleted\n";
return(false);
};
#if BCL35
d.Synchronize();
#else
RunAsSync(async() => await d.SynchronizeAsync());
#endif
}
}
if (!string.IsNullOrEmpty(failureMessage))
{
Assert.Fail(failureMessage);
}
}
/// <summary>
/// Test Case:
/// </summary>
//[TestMethod]
//[TestCategory("SyncManager")]
public void MergeTest()
{
var epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
string uniqueName = ((DateTime.UtcNow - epoch).TotalSeconds).ToString();
string uniqueName2 = uniqueName + "_";
string failureMessage = string.Empty;
UnAuthCredentials.Clear();
using (CognitoSyncManager sm1 = new CognitoSyncManager(AuthCredentials))
{
sm1.WipeData(false);
Thread.Sleep(2000);
using (Dataset d = sm1.OpenOrCreateDataset("test"))
{
d.Put(uniqueName, uniqueName);
d.OnSyncSuccess += delegate(object s1, SyncSuccessEventArgs e1)
{
UnAuthCredentials.Clear();
using (CognitoSyncManager sm2 = new CognitoSyncManager(UnAuthCredentials))
{
Thread.Sleep(2000);
using (Dataset d2 = sm2.OpenOrCreateDataset("test"))
{
d2.Put(uniqueName2, uniqueName2);
d2.OnSyncSuccess += delegate(object s2, SyncSuccessEventArgs e2)
{
AuthCredentials.Clear();
UnAuthCredentials.Clear();
//now we will use auth credentials.
using (CognitoSyncManager sm3 = new CognitoSyncManager(AuthCredentials))
{
Thread.Sleep(2000);
using (Dataset d3 = sm3.OpenOrCreateDataset("test"))
{
bool mergeTriggered = false;
d3.OnSyncSuccess += (object sender, SyncSuccessEventArgs e) =>
{
if (!mergeTriggered)
{
failureMessage += "Expecting DatasetMerged instead of OnSyncSuccess\n";
}
};
d3.OnSyncFailure += (object sender, SyncFailureEventArgs e) =>
{
failureMessage += string.Format("Not expecting OnSyncFailure Got exception {0}\n", e.Exception.Message);
};
d3.OnSyncConflict += (Dataset dataset, List <SyncConflict> syncConflicts) =>
{
failureMessage += "Not expecting OnSyncConflict\n";
return(false);
};
d3.OnDatasetDeleted += (Dataset dataset) =>
{
failureMessage += "Not expecting OnDatasetDeleted\n";
return(false);
};
d3.OnDatasetMerged += (Dataset ds, List <string> datasetNames) =>
{
mergeTriggered = true;
return(true);
};
#if BCL35
d3.Synchronize();
#else
RunAsSync(async() => await d3.SynchronizeAsync());
#endif
}
}
};
d2.OnSyncFailure += (object sender, SyncFailureEventArgs e) =>
{
failureMessage += string.Format("Not expecting OnSyncFailure Got exception {0}\n", e.Exception.Message);
};
d2.OnSyncConflict += (Dataset dataset, List <SyncConflict> conflicts) =>
{
failureMessage += "Not expecting OnSyncConflict\n";
return(false);
};
d2.OnDatasetDeleted += (Dataset dataset) =>
{
failureMessage += "Not expecting OnDatasetDeleted\n";
return(false);
};
d2.OnDatasetMerged += (Dataset dataset, List <string> datasetNames) =>
{
failureMessage += "Not expecting OnDatasetMerged\n";
return(false);
};
#if BCL35
d2.Synchronize();
#else
RunAsSync(async() => await d2.SynchronizeAsync());
#endif
}
}
};
d.OnSyncFailure += delegate(object s, SyncFailureEventArgs e)
{
failureMessage += string.Format("Not expecting OnSyncFailure Got exception {0}\n", e.Exception.Message);
};
d.OnSyncConflict += (Dataset dataset, List <SyncConflict> syncConflicts) =>
{
failureMessage += "Not expecting OnSyncConflict\n";
return(false);
};
d.OnDatasetDeleted += (Dataset dataset) =>
{
failureMessage += "Not expecting OnDatasetDeleted\n";
return(false);
};
d.OnDatasetMerged += (Dataset dataset, List <string> datasetNames) =>
{
failureMessage += "Not expecting OnDatasetMerged\n";
return(false);
};
#if BCL35
d.Synchronize();
#else
RunAsSync(async() => await d.SynchronizeAsync());
#endif
}
}
if (!string.IsNullOrEmpty(failureMessage))
{
Assert.Fail(failureMessage);
}
}
/// <summary>
/// Test case: Check that the dataset metadata is modified appropriately when calling Synchronize.
/// We test for the dirty bit, the sync count and the last modified timmestamp.
/// </summary>
//[TestMethod]
//[TestCategory("SyncManager")]
public void MetadataTest()
{
string failureMessage = string.Empty;
using (CognitoSyncManager syncManager = new CognitoSyncManager(UnAuthCredentials))
{
syncManager.WipeData(false);
using (Dataset d = syncManager.OpenOrCreateDataset("testDataset6"))
{
d.Put("testKey3", "the initial value");
//Initial properties
var records = d.Records;
Record r = d.Records[records.Count - 1];
long initialSyncCount = r.SyncCount;
bool initialDirty = r.IsModified;
DateTime initialDate = r.DeviceLastModifiedDate.Value;
d.OnSyncSuccess += delegate(object sender, SyncSuccessEventArgs e)
{
//Properties after Synchronize
Record r2 = d.Records[records.Count - 1];
long synchronizedSyncCount = r2.SyncCount;
bool synchronizedDirty = r2.IsModified;
DateTime synchronizedDate = r2.DeviceLastModifiedDate.Value;
d.Put("testKey3", "a new value");
//Properties after changing the content again
Record r3 = d.Records[records.Count - 1];
long finalSyncCount = r3.SyncCount;
bool finalDirty = r3.IsModified;
DateTime finalDate = r3.DeviceLastModifiedDate.Value;
if (!initialDirty)
{
failureMessage += "Expected 'initialDirty' to be true\n";
}
if (synchronizedDirty)
{
failureMessage += "Expected 'synchronizedDirty' to be false\n";
}
if (!finalDirty)
{
failureMessage += "Expected 'finalDirty' to be true\n";
}
if (synchronizedSyncCount <= initialSyncCount)
{
failureMessage += "Expected synchronizedSyncCount > initialSyncCount\n";
}
if (synchronizedSyncCount != finalSyncCount)
{
failureMessage += "Expected synchronizedSyncCount == finalSyncCount\n";
}
if (finalDate <= initialDate)
{
failureMessage += "Expected finalDate > initialDate\n";
}
if (initialDate != synchronizedDate)
{
failureMessage += "Expected initialDate == synchronizedDate\n";
}
};
d.OnSyncFailure += (object sender, SyncFailureEventArgs e) =>
{
failureMessage += e.Exception.ToString() + "\n";
};
#if BCL35
d.Synchronize();
#else
RunAsSync(async() => await d.SynchronizeAsync());
#endif
if (!string.IsNullOrEmpty(failureMessage))
{
Assert.Fail(failureMessage);
}
}
}
}
/// <summary>
/// Test case: Produce a conflict and check that the three ways provided by the SDK
/// for resolving a conflict (local wins, remote wins, and override) work. We also check
/// that returning true in SyncConflict allows the Synchronization operationn to continue.
/// </summary>
//[TestMethod]
//[TestCategory("SyncManager")]
public void ResolveConflictTest()
{
string failureMessage = string.Empty;
using (CognitoSyncManager syncManager = new CognitoSyncManager(UnAuthCredentials))
{
syncManager.WipeData(false);
using (Dataset d = syncManager.OpenOrCreateDataset("testDataset4"))
{
d.Put("a", "1");
d.Put("b", "2");
d.Put("c", "3");
d.OnSyncSuccess += delegate(object sender, SyncSuccessEventArgs e)
{
d.ClearAllDelegates();
syncManager.WipeData(false);
using (Dataset d2 = syncManager.OpenOrCreateDataset("testDataset4"))
{
d2.Put("a", "10");
d2.Put("b", "20");
d2.Put("c", "30");
bool resolved = false;
d2.OnSyncConflict += delegate(Dataset dataset, List <SyncConflict> conflicts)
{
List <Amazon.CognitoSync.SyncManager.Record> resolvedRecords = new List <Amazon.CognitoSync.SyncManager.Record>();
int i = 0;
foreach (SyncConflict conflictRecord in conflicts)
{
if (i == 0)
{
resolvedRecords.Add(conflictRecord.ResolveWithLocalRecord());
}
else if (i == 1)
{
resolvedRecords.Add(conflictRecord.ResolveWithValue("42"));
}
else
{
resolvedRecords.Add(conflictRecord.ResolveWithRemoteRecord());
}
i++;
}
dataset.Resolve(resolvedRecords);
resolved = true;
return(true);
};
d2.OnSyncSuccess += delegate(object sender4, SyncSuccessEventArgs e4)
{
if (resolved)
{
if (d2.Get("a") != "10")
{
failureMessage += "Value for key 'a' should be '10'\n";
}
if (d2.Get("b") != "42")
{
failureMessage += "Value for key 'b' should be '42'\n";
}
if (d2.Get("c") != "3")
{
failureMessage += "Value for key 'c' should be '3'\n";
}
}
else
{
failureMessage += "Expecting SyncConflict instead of SyncSuccess\n";
}
};
d2.OnSyncFailure += delegate(object sender4, SyncFailureEventArgs e4)
{
failureMessage += "Expecting SyncConflict instead of SyncFailure\n";
};
#if BCL35
d2.Synchronize();
#else
RunAsSync(async() => await d2.SynchronizeAsync());
#endif
}
};
#if BCL35
d.Synchronize();
#else
RunAsSync(async() => await d.SynchronizeAsync());
#endif
}
}
if (!string.IsNullOrEmpty(failureMessage))
{
Assert.Fail(failureMessage);
}
}
public void DatasetCloudStorageTest()
{
AutoResetEvent ars = new AutoResetEvent(false);
string failureMessage = string.Empty;
CognitoSyncManager syncManager = null;
AutoResetEvent mainThreadArs = new AutoResetEvent(false);
Amazon.Runtime.Internal.UnityRequestQueue.Instance.ExecuteOnMainThread(() =>
{
syncManager = new CognitoSyncManager(UnAuthCredentials, TestRunner.RegionEndpoint);
mainThreadArs.Set();
});
mainThreadArs.WaitOne();
syncManager.WipeData(false);
Thread.Sleep(2000);
Dataset d = syncManager.OpenOrCreateDataset("testDataset2");
d.Put("key", "he who must not be named");
d.OnSyncSuccess += delegate(object sender, SyncSuccessEventArgs e)
{
d.ClearAllDelegates();
string erasedValue = d.Get("key");
syncManager.WipeData(false);
d.OnSyncSuccess += delegate(object sender2, SyncSuccessEventArgs e2)
{
string restoredValues = d.Get("key");
if (erasedValue == null)
{
failureMessage += "erasedValue should not be null\n";
}
if (restoredValues == null)
{
failureMessage += "restoredValues should not be null\n";
}
if (erasedValue != restoredValues)
{
failureMessage += "erasedValue should equal restoredValues\n";
}
ars.Set();
};
d.OnSyncFailure += delegate(object sender2, SyncFailureEventArgs e2)
{
failureMessage += "sync failed\n";
ars.Set();
};
d.SynchronizeAsync(new AsyncOptions {
ExecuteCallbackOnMainThread = false
});
};
d.OnSyncFailure += delegate(object sender, SyncFailureEventArgs e)
{
failureMessage += "sync failed\n";
ars.Set();
};
d.OnSyncConflict += delegate(Dataset dataset, List <SyncConflict> conflicts)
{
failureMessage += "Expected SyncSuccess instead of SyncConflict\n";
return(false);
};
d.OnDatasetMerged += (Dataset dataset, List <string> datasetNames) =>
{
failureMessage += "Did not expect DatasetMerged\n";
return(false);
};
d.OnDatasetDeleted += (Dataset dataset) =>
{
failureMessage += "Did not expect DatasetDeleted\n";
return(false);
};
d.SynchronizeAsync(new AsyncOptions {
ExecuteCallbackOnMainThread = false
});
ars.WaitOne();
d.Dispose();
syncManager.Dispose();
Utils.AssertStringIsNullOrEmpty(failureMessage);
}
public void MetadataTest()
{
AutoResetEvent ars = new AutoResetEvent(false);
string failureMessage = string.Empty;
CognitoSyncManager syncManager = null;
AutoResetEvent mainThreadArs = new AutoResetEvent(false);
Amazon.Runtime.Internal.UnityRequestQueue.Instance.ExecuteOnMainThread(() =>
{
syncManager = new CognitoSyncManager(UnAuthCredentials, TestRunner.RegionEndpoint);
mainThreadArs.Set();
});
mainThreadArs.WaitOne();
syncManager.WipeData(false);
using (Dataset d = syncManager.OpenOrCreateDataset("testDataset6"))
{
d.Put("testKey3", "the initial value");
//Initial properties
var records = d.Records;
Record r = d.Records[records.Count - 1];
long initialSyncCount = r.SyncCount;
bool initialDirty = r.IsModified;
DateTime initialDate = r.DeviceLastModifiedDate.Value;
d.OnSyncSuccess += delegate(object sender, SyncSuccessEventArgs e)
{
//Properties after Synchronize
Record r2 = d.Records[records.Count - 1];
long synchronizedSyncCount = r2.SyncCount;
bool synchronizedDirty = r2.IsModified;
DateTime synchronizedDate = r2.DeviceLastModifiedDate.Value;
d.Put("testKey3", "a new value");
//Properties after changing the content again
Record r3 = d.Records[records.Count - 1];
long finalSyncCount = r3.SyncCount;
bool finalDirty = r3.IsModified;
DateTime finalDate = r3.DeviceLastModifiedDate.Value;
if (!initialDirty)
{
failureMessage += "Expected 'initialDirty' to be true\n";
}
if (synchronizedDirty)
{
failureMessage += "Expected 'synchronizedDirty' to be false\n";
}
if (!finalDirty)
{
failureMessage += "Expected 'finalDirty' to be true\n";
}
if (synchronizedSyncCount <= initialSyncCount)
{
failureMessage += "Expected synchronizedSyncCount > initialSyncCount\n";
}
if (synchronizedSyncCount != finalSyncCount)
{
failureMessage += "Expected synchronizedSyncCount == finalSyncCount\n";
}
if (finalDate <= initialDate)
{
failureMessage += "Expected finalDate > initialDate\n";
}
if (initialDate != synchronizedDate)
{
Debug.LogWarning(initialDate);
Debug.LogWarning(synchronizedDate);
failureMessage += "Expected initialDate == synchronizedDate\n";
}
ars.Set();
};
d.OnSyncFailure += (object sender, SyncFailureEventArgs e) =>
{
failureMessage += e.Exception.ToString() + "\n";
ars.Set();
};
d.SynchronizeAsync(new AsyncOptions {
ExecuteCallbackOnMainThread = false
});
ars.WaitOne();
}
syncManager.Dispose();
Utils.AssertStringIsNullOrEmpty(failureMessage);
}
public void WipeDataTest()
{
AutoResetEvent ars = new AutoResetEvent(false);
string failureMessage = string.Empty;
CognitoSyncManager syncManager = null;
AutoResetEvent mainThreadArs = new AutoResetEvent(false);
Amazon.Runtime.Internal.UnityRequestQueue.Instance.ExecuteOnMainThread(() =>
{
syncManager = new CognitoSyncManager(UnAuthCredentials, TestRunner.RegionEndpoint);
mainThreadArs.Set();
});
mainThreadArs.WaitOne();
syncManager.WipeData(false);
Dataset d = syncManager.OpenOrCreateDataset("testDataset5");
Dataset d2 = null;
d.Put("testKey", "testValue");
d.OnSyncConflict += delegate(Dataset dataset, List <SyncConflict> conflicts)
{
failureMessage += "Expecting SyncSuccess instead of SyncConflict\n";
return(false);
};
d.OnSyncFailure += delegate(object sender, SyncFailureEventArgs e)
{
failureMessage += "Expecting SyncSuccess instead of SyncFailure\n";
ars.Set();
};
d.OnSyncSuccess += delegate(object sender, SyncSuccessEventArgs e)
{
syncManager.WipeData();
d2 = syncManager.OpenOrCreateDataset("testDataset5");
if (d2.Records.Count != 0)
{
failureMessage += "Expecting dataset to be empty due to local data wipe.\n";
}
d2.Put("testKey", "newTestValue");
d2.OnSyncConflict += delegate(Dataset dataset, List <SyncConflict> conflicts)
{
failureMessage += "Expecting SyncSuccess instead of SyncConflict\n";
return(false);
};
d2.OnSyncFailure += delegate(object sender2, SyncFailureEventArgs e2)
{
failureMessage += "Expecting SyncSuccess instead of SyncFailure\n";
ars.Set();
};
d2.OnSyncSuccess += delegate(object sender2, SyncSuccessEventArgs e2)
{
if (d2.Get("testKey") != "newTestValue")
{
failureMessage += "Value for key 'testKey' should be 'newTestValue'\n";
}
ars.Set();
};
d2.SynchronizeAsync(new AsyncOptions {
ExecuteCallbackOnMainThread = false
});
};
d.SynchronizeAsync(new AsyncOptions {
ExecuteCallbackOnMainThread = false
});
ars.WaitOne();
syncManager.Dispose();
d.Dispose();
if (d2 != null)
{
d2.Dispose();
}
Utils.AssertStringIsNullOrEmpty(failureMessage);
}
public void ResolveConflictTest()
{
AutoResetEvent ars = new AutoResetEvent(false);
string failureMessage = string.Empty;
CognitoSyncManager syncManager = null;
AutoResetEvent mainThreadArs = new AutoResetEvent(false);
Amazon.Runtime.Internal.UnityRequestQueue.Instance.ExecuteOnMainThread(() =>
{
syncManager = new CognitoSyncManager(UnAuthCredentials, TestRunner.RegionEndpoint);
mainThreadArs.Set();
});
mainThreadArs.WaitOne();
syncManager.WipeData(false);
Dataset d = syncManager.OpenOrCreateDataset("testDataset4");
Dataset d2 = null;
d.Put("a", "1");
d.Put("b", "2");
d.Put("c", "3");
d.OnSyncSuccess += delegate(object sender, SyncSuccessEventArgs e)
{
d.ClearAllDelegates();
syncManager.WipeData(false);
d2 = syncManager.OpenOrCreateDataset("testDataset4");
d2.Put("a", "10");
d2.Put("b", "20");
d2.Put("c", "30");
bool resolved = false;
d2.OnSyncConflict += delegate(Dataset dataset, List <SyncConflict> conflicts)
{
List <Amazon.CognitoSync.SyncManager.Record> resolvedRecords = new List <Amazon.CognitoSync.SyncManager.Record>();
int i = 0;
foreach (SyncConflict conflictRecord in conflicts)
{
if (i == 0)
{
resolvedRecords.Add(conflictRecord.ResolveWithLocalRecord());
}
else if (i == 1)
{
resolvedRecords.Add(conflictRecord.ResolveWithValue("42"));
}
else
{
resolvedRecords.Add(conflictRecord.ResolveWithRemoteRecord());
}
i++;
}
dataset.Resolve(resolvedRecords);
resolved = true;
return(true);
};
d2.OnSyncSuccess += delegate(object sender4, SyncSuccessEventArgs e4)
{
if (resolved)
{
if (d2.Get("a") != "10")
{
failureMessage += "Value for key 'a' should be '10'\n";
}
if (d2.Get("b") != "42")
{
failureMessage += "Value for key 'b' should be '42'\n";
}
if (d2.Get("c") != "3")
{
failureMessage += "Value for key 'c' should be '3'\n";
}
}
else
{
failureMessage += "Expecting SyncConflict instead of SyncSuccess\n";
}
ars.Set();
};
d2.OnSyncFailure += delegate(object sender4, SyncFailureEventArgs e4)
{
failureMessage += "Expecting SyncConflict instead of SyncFailure\n";
ars.Set();
};
d2.SynchronizeAsync(new AsyncOptions {
ExecuteCallbackOnMainThread = false
});
};
d.OnSyncFailure += delegate(object sender4, SyncFailureEventArgs e4)
{
failureMessage += "Expecting SyncConflict instead of SyncFailure\n";
ars.Set();
};
d.SynchronizeAsync(new AsyncOptions {
ExecuteCallbackOnMainThread = false
});
ars.WaitOne();
d.Dispose();
if (d2 != null)
{
d2.Dispose();
}
syncManager.Dispose();
Utils.AssertStringIsNullOrEmpty(failureMessage);
}
public void ConflictTest()
{
AutoResetEvent ars = new AutoResetEvent(false);
string failureMessage = string.Empty;
CognitoSyncManager syncManager = null;
AutoResetEvent mainThreadArs = new AutoResetEvent(false);
Amazon.Runtime.Internal.UnityRequestQueue.Instance.ExecuteOnMainThread(() =>
{
syncManager = new CognitoSyncManager(UnAuthCredentials, TestRunner.RegionEndpoint);
mainThreadArs.Set();
});
mainThreadArs.WaitOne();
syncManager.WipeData(false);
Dataset d = syncManager.OpenOrCreateDataset("testDataset3");
Dataset d2 = null;
d.Put("testKey3", "the initial value");
d.OnSyncSuccess += delegate(object sender, SyncSuccessEventArgs e)
{
d.ClearAllDelegates();
syncManager.WipeData(false);
d2 = syncManager.OpenOrCreateDataset("testDataset3");
bool conflictTriggered = false;
d2.Put("testKey3", "a different value");
d2.OnSyncConflict += delegate(Dataset dataset, List <SyncConflict> conflicts)
{
conflictTriggered = true;
return(false);
};
d2.OnSyncSuccess += delegate(object sender4, SyncSuccessEventArgs e4)
{
failureMessage += "Expecting OnSyncConflict instead of OnSyncSuccess\n";
ars.Set();
};
d2.OnSyncFailure += delegate(object sender4, SyncFailureEventArgs e4)
{
if (!conflictTriggered)
{
failureMessage += "Expecting OnSyncConflict instead of OnSyncFailure\n";
}
ars.Set();
};
d2.SynchronizeAsync(new AsyncOptions {
ExecuteCallbackOnMainThread = false
});
};
d.OnSyncFailure += delegate(object sender4, SyncFailureEventArgs e4)
{
failureMessage += "Expecting OnSyncSuccess instead of OnSyncFailure\n";
ars.Set();
};
d.SynchronizeAsync(new AsyncOptions {
ExecuteCallbackOnMainThread = false
});
ars.WaitOne();
if (d2 != null)
{
d2.Dispose();
}
d.Dispose();
syncManager.Dispose();
Utils.AssertStringIsNullOrEmpty(failureMessage);
}
