public void CreateQueryRequest_Any_ReturnsQueryWrappedInQueryRequest()
{
// Arrange
var bucket = new Mock<IBucket>();
bucket.Setup(m => m.Name).Returns("default");
bucket.Setup(m => m.Configuration).Returns(new BucketConfiguration()
{
PoolConfiguration = new PoolConfiguration(new ClientConfiguration())
});
var context = new BucketContext(bucket.Object);
var query = context.Query<Brewery>();
// Act
var result = LinqQueryRequest.CreateQueryRequest(query, p => p.Any(q => q.Name == "name"));
// Assert
const string queryStr = "SELECT true as result FROM `default` as `Extent1` WHERE (`Extent1`.`name` = 'name') LIMIT 1";
Assert.NotNull(result);
Assert.AreEqual(queryStr, result.GetOriginalStatement());
Assert.True(result.ScalarResultBehavior.ResultExtractionRequired);
Assert.AreEqual(false, result.ScalarResultBehavior.NoRowsResult);
}
public void BeginChangeTracking_DoesNotClear_Modified_List()
{
var db = new BucketContext(ClusterHelper.GetBucket("beer-sample"));
db.BeginChangeTracking();
var query = from x in db.Query<Beer>()
where x.Type == "beer"
select x;
db.BeginChangeTracking();
var context = db as IChangeTrackableContext;
Assert.AreEqual(0, context.ModifiedCount);
var brewery = query.First();
brewery.Abv = 10;
Assert.AreEqual(1, context.ModifiedCount);
db.BeginChangeTracking();
Assert.AreEqual(1, context.ModifiedCount);
}
public async Task ExecuteAsync_WithAvg_ReturnsAvg()
{
var bucket = ClusterHelper.GetBucket("beer-sample");
var context = new BucketContext(bucket);
var beers = from b in context.Query<Beer>()
select b;
var result = await beers.ExecuteAsync(p => p.Average(q => q.Abv));
Console.WriteLine(result);
}
public void Test_Basic_Query()
{
var db = new BucketContext(ClusterHelper.GetBucket("beer-sample"));
var query = from x in db.Query<Beer>()
where x.Type == "beer"
select x;
foreach (var beer in query)
{
Console.WriteLine(beer.Name);
}
}
public void AggregateTests_JoinBeforeGroupByAndMultipartKey()
{
var bucket = ClusterHelper.GetBucket("beer-sample");
var context = new BucketContext(bucket);
var breweries =
from beer in context.Query<Beer>()
join brewery in context.Query<Brewery>() on beer.BreweryId equals N1QlFunctions.Key(brewery)
where beer.Type == "beer"
group beer by new {breweryid = beer.BreweryId, breweryName = brewery.Name}
into g
select new {g.Key.breweryName, count = g.Count(), avgAbv = g.Average(p => p.Abv)};
var results = breweries.Take(1).ToList();
Assert.AreEqual(1, results.Count);
foreach (var brewery in results)
{
Console.WriteLine("Brewery {0} has {1} beers with {2:f2} average ABV", brewery.breweryName,
brewery.count, brewery.avgAbv);
}
}
public async Task ExecuteAsync_Any_ReturnsTrue()
{
var bucket = ClusterHelper.GetBucket("beer-sample");
var context = new BucketContext(bucket);
var beers = from b in context.Query<Beer>()
where b.Type == "beer" && b.Name == "21A IPA"
select b;
var result = await beers.ExecuteAsync(p => p.Any());
Assert.True(result);
}
public async Task ExecuteAsync_FirstOrDefaultNoValues_ReturnsDefault()
{
var bucket = ClusterHelper.GetBucket("beer-sample");
var context = new BucketContext(bucket);
var beers = from b in context.Query<Beer>()
where b.Name == "abcdefg"
select b.Abv;
var result = await beers.ExecuteAsync(p => p.FirstOrDefault());
Assert.AreEqual(0M, result);
}
public async Task ExecuteAsync_First_ReturnsFirst()
{
var bucket = ClusterHelper.GetBucket("beer-sample");
var context = new BucketContext(bucket);
var beers = from b in context.Query<Beer>()
select b;
var result = await beers.ExecuteAsync(p => p.First());
Assert.NotNull(result);
Console.WriteLine(result.Name);
}
public void AggregateTests_JoinBeforeGroupByAndMultipartKey()
{
using (var cluster = new Cluster(TestConfigurations.DefaultConfig()))
{
using (var bucket = cluster.OpenBucket("beer-sample"))
{
var context = new BucketContext(bucket);
var breweries =
from beer in context.Query<Beer>()
join brewery in context.Query<Brewery>() on beer.BreweryId equals N1QlFunctions.Key(brewery)
where beer.Type == "beer"
group beer by new { breweryid = beer.BreweryId, breweryName = brewery.Name }
into g
select new { g.Key.breweryName, count = g.Count(), avgAbv = g.Average(p => p.Abv) };
foreach (var brewery in breweries)
{
Console.WriteLine("Brewery {0} has {1} beers with {2:f2} average ABV", brewery.breweryName, brewery.count, brewery.avgAbv);
}
}
}
}
public async Task ExecuteAsync_NoParameters_ReturnsList()
{
var bucket = ClusterHelper.GetBucket("beer-sample");
var context = new BucketContext(bucket);
var beers = from b in context.Query<Beer>()
select b;
var results = (await beers.Take(1).ExecuteAsync()).ToList();
Assert.AreEqual(1, results.Count);
foreach (var beer in results)
{
Console.WriteLine(beer.Name);
}
}
public void Query_DisableProxyGeneration_ReturnsNoProxy()
{
var db = new BucketContext(ClusterHelper.GetBucket("beer-sample"));
const string documentId = "21st_amendment_brewery_cafe-21a_ipa";
var query = from x in db.Query<Beer>().UseKeys(new[] { documentId })
where x.Type == "beer"
select x;
var beer = query.First();
// ReSharper disable once SuspiciousTypeConversion.Global
var status = beer as ITrackedDocumentNode;
Assert.Null(status);
}
static void Main(string[] args)
{
var config = new ClientConfiguration
{
Servers = new List<Uri> { new Uri("http://localhost:8091") }
};
ClusterHelper.Initialize(config);
var db = new BucketContext(ClusterHelper.GetBucket("beer-sample"));
var query = from b in db.Query<Beer>()
select b;
foreach (var beer in query)
{
Console.WriteLine(beer.Type + ": " + beer.Name);
}
Console.Read();
ClusterHelper.Close();
}
public void AggregateTests_GroupBy()
{
var bucket = ClusterHelper.GetBucket("beer-sample");
var context = new BucketContext(bucket);
var breweries =
from beer in context.Query<Beer>()
where beer.Type == "beer"
group beer by beer.BreweryId
into g
orderby g.Key
select new {breweryid = g.Key, count = g.Count(), avgAbv = g.Average(p => p.Abv)};
var results = breweries.Take(1).ToList();
Assert.AreEqual(1, results.Count);
foreach (var brewery in results)
{
Console.WriteLine("Brewery {0} has {1} beers with {2:f2} average ABV", brewery.breweryid, brewery.count,
brewery.avgAbv);
}
}
public void Query_EnableProxyGenerationAddAddress_FlagAsDirty()
{
var db = new BucketContext(ClusterHelper.GetBucket("beer-sample"))
{
EnableChangeTracking = true
};
var query = from x in db.Query<Brewery>()
where x.Type == "brewery" && x.Address.Any()
select x;
var brewery = query.First();
var addresses = brewery.Address;
addresses.Add("Test");
// ReSharper disable once SuspiciousTypeConversion.Global
var status = addresses as ITrackedDocumentNode;
Assert.NotNull(status);
Assert.IsTrue(status.IsDirty);
}
public void AggregateTests_GroupBy()
{
using (var cluster = new Cluster(TestConfigurations.DefaultConfig()))
{
using (var bucket = cluster.OpenBucket("beer-sample"))
{
var context = new BucketContext(bucket);
var breweries =
from beer in context.Query<Beer>()
where beer.Type == "beer"
group beer by beer.BreweryId
into g
orderby g.Key
select new { breweryid = g.Key, count = g.Count(), avgAbv = g.Average(p => p.Abv)};
foreach (var brewery in breweries)
{
Console.WriteLine("Brewery {0} has {1} beers with {2:f2} average ABV", brewery.breweryid, brewery.count, brewery.avgAbv);
}
}
}
}
public void Query_EnableProxyGenerationChangesInSubDocuments_FlagAsDirty()
{
var db = new BucketContext(ClusterHelper.GetBucket("beer-sample"))
{
EnableChangeTracking = true
};
var query = from x in db.Query<Brewery>()
where x.Type == "brewery" && N1QlFunctions.IsValued(x.Geo)
select x;
var beer = query.First();
// ReSharper disable once SuspiciousTypeConversion.Global
var status = beer as ITrackedDocumentNode;
Assert.NotNull(status);
Assert.False(status.IsDirty);
beer.Geo.Latitude = 90M;
Assert.True(status.IsDirty);
}
public void Map2PocoTests_Simple_Projections_WhereDateTime()
{
using (var cluster = new Cluster(TestConfigurations.DefaultConfig()))
{
using (var bucket = cluster.OpenBucket("beer-sample"))
{
var context = new BucketContext(bucket);
var beers = from b in context.Query<Beer>()
where (b.Type == "beer") && (b.Updated >= new DateTime(2010, 1, 1))
select new { name = b.Name, updated = b.Updated };
foreach (var b in beers.Take(20))
{
Console.WriteLine("{0} last updated {1:g}", b.name, b.updated);
}
}
}
}
public void Map2PocoTests_Simple_Projections_TypeFilterRuntime()
{
DocumentFilterManager.SetFilter(new BreweryFilter());
using (var cluster = new Cluster(TestConfigurations.DefaultConfig()))
{
using (var bucket = cluster.OpenBucket("beer-sample"))
{
var context = new BucketContext(bucket);
var breweries = (from b in context.Query<Brewery>()
select new {type = b.Type})
.AsEnumerable();
Assert.True(breweries.All(p => p.type == "brewery"));
}
}
}
public void Map2PocoTests_Simple_Projections_TypeFilterAttribute()
{
using (var cluster = new Cluster(TestConfigurations.DefaultConfig()))
{
using (var bucket = cluster.OpenBucket("beer-sample"))
{
var context = new BucketContext(bucket);
var beers = (from b in context.Query<BeerFiltered>()
select new {type = b.Type}).
AsEnumerable();
Assert.True(beers.All(p => p.type == "beer"));
}
}
}
public async Task Query()
{
// Ensure that the database starts out empty.
couchbase.Clear();
await Assert.ThrowsAsync <CouchbaseKeyValueResponseException>(async() => await bucket.GetSafeAsync <string>("jack"));
await Assert.ThrowsAsync <CouchbaseKeyValueResponseException>(async() => await bucket.GetSafeAsync <string>("jill"));
// Write a couple documents and then query for them. Note
// that we're explicitly using [RequestPlus] consistency
// and we're doing a synchronous query.
await bucket.UpsertSafeAsync("jack", new TestDoc()
{
Name = "Jack", Age = 11
});
await bucket.UpsertSafeAsync("jill", new TestDoc()
{
Name = "Jill", Age = 12
});
var context = new BucketContext(bucket);
// Note that we're explicitly using [RequestPlus] consistency
// and we're doing a synchronous query.
var query =
from doc in context.Query <TestDoc>()
.ScanConsistency(Couchbase.N1QL.ScanConsistency.RequestPlus)
select doc;
var results = query.ToList();
Assert.Equal(2, results.Count);
Assert.Single(results.Where(doc => doc.Name == "Jack"));
Assert.Single(results.Where(doc => doc.Name == "Jill"));
// Use Couchbase [IQueryable<T>.ExecuteAsync()] to execute the query
// and enable result streaming from the server.
query =
from doc in context.Query <TestDoc>()
.ScanConsistency(Couchbase.N1QL.ScanConsistency.RequestPlus)
.UseStreaming(true)
select doc;
await query.ExecuteAsync();
results = query.ToList();
Assert.Equal(2, results.Count);
Assert.Single(results.Where(doc => doc.Name == "Jack"));
Assert.Single(results.Where(doc => doc.Name == "Jill"));
// Do a string based query using the [QueryAsync()] extension
// method which throws an exception on errors. Note that this doesn't
// appear to be compatible with streaming (Rows is NULL).
var queryRequest = new QueryRequest($"select {bucket.Name}.* from {bucket.Name}")
.ScanConsistency(ScanConsistency.RequestPlus);
var queryResult = await bucket.QueryAsync <TestDoc>(queryRequest);
var rows = queryResult.Rows;
Assert.Equal(2, rows.Count);
Assert.Single(rows.Where(doc => doc.Name == "Jack"));
Assert.Single(rows.Where(doc => doc.Name == "Jill"));
// Do a string based query using the [QuerySafeAsync()] extension
// method which throws an exception on errors. Note that this doesn't
// appear to be compatible with streaming (the result is NULL).
queryRequest = new QueryRequest($"select {bucket.Name}.* from {bucket.Name}")
.ScanConsistency(ScanConsistency.RequestPlus);
results = await bucket.QuerySafeAsync <TestDoc>(queryRequest);
Assert.Equal(2, results.Count);
Assert.Single(results.Where(doc => doc.Name == "Jack"));
Assert.Single(results.Where(doc => doc.Name == "Jill"));
}
public void SingleOrDefault_HasResult()
{
using (var cluster = new Cluster(TestConfigurations.DefaultConfig()))
{
using (var bucket = cluster.OpenBucket("beer-sample"))
{
var context = new BucketContext(bucket);
var beers = from beer in context.Query<Beer>()
where beer.Name == "21A IPA"
select new { beer.Name };
var aBeer = beers.SingleOrDefault();
Assert.IsNotNull(aBeer);
Console.WriteLine(aBeer.Name);
}
}
}
public void NoProjection_Number()
{
using (var cluster = new Cluster(TestConfigurations.DefaultConfig()))
{
using (var bucket = cluster.OpenBucket("beer-sample"))
{
var context = new BucketContext(bucket);
var beers = (from b in context.Query<Beer>()
where b.Type == "beer"
select b.Abv).
Take(10);
foreach (var b in beers)
{
Console.WriteLine(b);
}
}
}
}
public void Map2PocoTests()
{
using (var cluster = new Cluster(
TestConfigurations.DefaultConfig()))
{
using (var bucket = cluster.OpenBucket("beer-sample"))
{
var context = new BucketContext(bucket);
var beers = from b in context.Query<Beer>()
select b;
foreach (var beer in beers)
{
Console.WriteLine(beer.Name);
}
}
}
}
public void JoinTests_LeftJoin_SortAndFilter()
{
using (var cluster = new Cluster(TestConfigurations.DefaultConfig()))
{
using (var bucket = cluster.OpenBucket("beer-sample"))
{
var context = new BucketContext(bucket);
var beers = from beer in context.Query<Beer>()
join breweryGroup in context.Query<Brewery>()
on beer.BreweryId equals N1QlFunctions.Key(breweryGroup) into bg
from brewery in bg.DefaultIfEmpty()
where beer.Abv > 4
orderby brewery.Name, beer.Name
select new {beer.Name, beer.Abv, BreweryName = brewery.Name};
foreach (var b in beers.Take(10))
{
Console.WriteLine("Beer {0} with ABV {1} is from {2}", b.Name, b.Abv, b.BreweryName);
}
}
}
}
public void Execute(CancellationToken cancellationToken)
{
using (new CouchbaseDistributedLock(DISTRIBUTED_LOCK_KEY, defaultLockTimeout, storage))
{
logger.Trace("Aggregating records in 'Counter' table.");
using (IBucket bucket = storage.Client.OpenBucket(storage.Options.DefaultBucket))
{
// context
BucketContext context = new BucketContext(bucket);
List <Counter> rawCounters = context.Query <Counter>()
.Where(c => c.DocumentType == DocumentTypes.Counter && c.Type == CounterTypes.Raw)
.ToList();
Dictionary <string, (int Value, int?ExpireOn, List <Counter> Counters)> counters = rawCounters.GroupBy(c => c.Key)
.ToDictionary(k => k.Key, v => (Value: v.Sum(c => c.Value), ExpireOn: v.Max(c => c.ExpireOn), Counters: v.ToList()));
foreach (string key in counters.Keys)
{
cancellationToken.ThrowIfCancellationRequested();
if (counters.TryGetValue(key, out var data))
{
Counter aggregated;
string id = $"{key}:{CounterTypes.Aggregate}".GenerateHash();
IOperationResult <Counter> operation = bucket.Get <Counter>(id, TimeSpan.FromMinutes(1));
if (operation.Success == false && operation.Value == null)
{
aggregated = new Counter
{
Id = id,
Key = key,
Type = CounterTypes.Aggregate,
Value = data.Value,
ExpireOn = data.ExpireOn
};
}
else if (operation.Success && operation.Value.Type == CounterTypes.Aggregate)
{
aggregated = operation.Value;
aggregated.Value += data.Value;
aggregated.ExpireOn = new[] { aggregated.ExpireOn, data.ExpireOn }.Max();
}
else
{
logger.Warn($"Document with ID: {id} is a {operation.Value.Type.ToString()} type");
continue;
}
IOperationResult <Counter> result = bucket.Upsert(aggregated.Id, aggregated);
if (result.Success)
{
IList <string> ids = data.Counters
.Select(counter => counter.Id)
.ToList();
bucket.Remove(ids, new ParallelOptions {
CancellationToken = cancellationToken
}, TimeSpan.FromMinutes(1));
logger.Trace($"Total {ids.Count} records from the 'Counter:{aggregated.Key}' were aggregated.");
}
}
}
}
logger.Trace("Records from the 'Counter' table aggregated.");
}
cancellationToken.WaitHandle.WaitOne(storage.Options.CountersAggregateInterval);
}
public void Map2PocoTests_Simple_Projections_WhereNot()
{
using (var cluster = new Cluster(TestConfigurations.DefaultConfig()))
{
using (var bucket = cluster.OpenBucket("beer-sample"))
{
var context = new BucketContext(bucket);
var beers = from b in context.Query<Beer>()
where b.Type == "beer" && !(b.Abv < 4)
select new {name = b.Name, abv = b.Abv};
foreach (var b in beers)
{
Console.WriteLine("{0} has {1} ABV", b.name, b.abv);
}
}
}
}
public void Map2PocoTests_Explain_QueryWithPropertyExtraction()
{
using (var cluster = new Cluster(TestConfigurations.DefaultConfig()))
{
using (var bucket = cluster.OpenBucket("beer-sample"))
{
var context = new BucketContext(bucket);
var explanation = (from b in context.Query<Beer>()
where b.Type == "beer"
select b.Abv).
Explain();
Console.WriteLine(explanation);
}
}
}
public void NestTests_Unnest_Sort()
{
using (var cluster = new Cluster(TestConfigurations.DefaultConfig()))
{
using (var bucket = cluster.OpenBucket("beer-sample"))
{
var context = new BucketContext(bucket);
var breweries = from brewery in context.Query<Brewery>()
from address in brewery.Address
orderby address
select new {name = brewery.Name, address};
foreach (var b in breweries.Take(10))
{
Console.WriteLine("Brewery {0} has address line {1}", b.name, b.address);
}
}
}
}
public void Map2PocoTests_NewObjectsInArray()
{
using (var cluster = new Cluster(TestConfigurations.DefaultConfig()))
{
using (var bucket = cluster.OpenBucket("beer-sample"))
{
var context = new BucketContext(bucket);
var query = from brewery in context.Query<Brewery>()
where brewery.Type == "brewery"
select
new
{
name = brewery.Name,
list =
new[]
{new {part = brewery.City}, new {part = brewery.State}, new {part = brewery.Code}}
};
foreach (var brewery in query.Take(10))
{
Console.WriteLine("Brewery {0} has address parts {1}", brewery.name,
String.Join(", ", brewery.list.Select(p => p.part)));
}
}
}
}
public void SingleOrDefault_Empty()
{
using (var cluster = new Cluster(TestConfigurations.DefaultConfig()))
{
using (var bucket = cluster.OpenBucket("beer-sample"))
{
var context = new BucketContext(bucket);
var beers = from beer in context.Query<Beer>()
where beer.Type == "abcdefg"
select new { beer.Name };
var aBeer = beers.SingleOrDefault();
Assert.IsNull(aBeer);
}
}
}
public void Map2PocoTests_Simple_Projections_MetaWhere()
{
using (var cluster = new Cluster(TestConfigurations.DefaultConfig()))
{
using (var bucket = cluster.OpenBucket("beer-sample"))
{
var context = new BucketContext(bucket);
var beers = (from b in context.Query<Beer>()
where b.Type == "beer" && N1QlFunctions.Meta(b).Type == "json"
select new {name = b.Name}).
Take(10);
foreach (var b in beers)
{
Console.WriteLine("{0} is a JSON document", b.name);
}
}
}
}
public void Single_Empty()
{
using (var cluster = new Cluster(TestConfigurations.DefaultConfig()))
{
using (var bucket = cluster.OpenBucket("beer-sample"))
{
var context = new BucketContext(bucket);
var beers = from beer in context.Query<Beer>()
where beer.Type == "abcdefg"
select new { beer.Name };
Assert.Throws<InvalidOperationException>(() =>
{
// ReSharper disable once UnusedVariable
var temp = beers.Single();
});
}
}
}
public async Task WriteReadList()
{
// Ensure that the database starts out empty.
Assert.Empty(from doc in context.Query <object>() select doc);
// Verify that the generated CreateKey() methods return the
// correct values.
Assert.Equal($"{Person.PersistedType}::0", Person.CreateKey("0"));
Assert.Equal($"{City.PersistedType}::Woodinville", City.CreateKey("Woodinville"));
// Verify that we can write generated entity models.
var jack = new Person()
{
Id = 0,
Name = "Jack",
Age = 10,
Gender = Gender.Male,
Data = new byte[] { 0, 1, 2, 3, 4 }
};
var jill = new Person()
{
Id = 1,
Name = "Jill",
Age = 11,
Gender = Gender.Female,
Data = new byte[] { 5, 6, 7, 8, 9 }
};
Assert.Equal("Test.Neon.Models.Definitions.Person::0", jack.GetKey());
Assert.Equal("Test.Neon.Models.Definitions.Person::1", jill.GetKey());
await bucket.UpsertSafeAsync(jack, persistTo : PersistTo.One);
await bucket.UpsertSafeAsync(jill, persistTo : PersistTo.One);
// Verify that we can read them.
var jackRead = await bucket.GetSafeAsync <Person>(Person.CreateKey(0));
var jillRead = await bucket.GetSafeAsync <Person>(Person.CreateKey(1));
Assert.Equal("Test.Neon.Models.Definitions.Person::0", jackRead.GetKey());
Assert.Equal("Test.Neon.Models.Definitions.Person::1", jillRead.GetKey());
Assert.True(jack == jackRead);
Assert.True(jill == jillRead);
//-----------------------------------------------------------------
// Persist a [City] entity (which has a different entity type) and then
// perform a N1QL query to list the Person entities and verify that we
// get only Jack and Jill back. This verifies the the [TypeFilter]
// attribute is generated and working correctly.
var city = new City()
{
Name = "Woodinville",
Population = 12345
};
var result = await bucket.UpsertAsync(city);
await bucket.WaitForIndexerAsync();
//-----------------------------------------------------------------
// Query for the people and verify
var peopleQuery = (from doc in context.Query <Person>() select doc);
var people = peopleQuery.ToList();
Assert.Equal(2, people.Count);
Assert.Contains(people, p => p.Name == "Jack");
Assert.Contains(people, p => p.Name == "Jill");
//-----------------------------------------------------------------
// Query for the city and verify.
var cityQuery = from doc in context.Query <City>() select doc;
var cities = cityQuery.ToList();
Assert.Single(cities);
Assert.Contains(cities, p => p.Name == "Woodinville");
//-----------------------------------------------------------------
// Query for documents that don't exist and verify.
var rawResults = await bucket.QueryAsync <object>($"select * from `{bucket.Name}` where __T=\"Test.Neon.Models.Definitions.Country\";");
var countryQuery = from doc in context.Query <Country>() select doc;
Assert.Empty(rawResults.ToList());
Assert.Empty(countryQuery.ToList()); // $todo(jefflill): https://github.com/nforgeio/neonKUBE/issues/475
//-----------------------------------------------------------------
// Verify that plain old object serialization still works.
var poo = new PlainOldObject()
{
Foo = "bar"
};
await bucket.UpsertSafeAsync("poo", poo, persistTo : PersistTo.One);
poo = await bucket.GetSafeAsync <PlainOldObject>("poo");
Assert.Equal("bar", poo.Foo);
//-----------------------------------------------------------------
// Extra credit #1: Verify that [DeepClone()] works.
var clone = jack.DeepClone();
Assert.Equal(jack.Name, clone.Name);
Assert.Equal(jack.Age, clone.Age);
Assert.Equal(jack.Gender, clone.Gender);
Assert.NotSame(jack.Data, clone.Data);
//-----------------------------------------------------------------
// Extra credit #2: Verify that [SameTypeAs()] works.
Assert.True(Person.SameTypeAs(jack));
Assert.False(Person.SameTypeAs(city));
Assert.False(Person.SameTypeAs(null));
}
