public bool TestNestedGroups()
{
NcFile file = null;
NcDim dim;
Dictionary <string, NcGroup> groups;
try {
file = TestHelper.NewFile(filePath);
NcGroup a = file.AddGroup("a");
Assert.False(a.IsNull());
NcGroup b = file.AddGroup("b");
Assert.False(b.IsNull());
NcGroup a1 = a.AddGroup("a1");
Assert.False(a1.IsNull());
NcGroup a2 = a.AddGroup("a2");
Assert.False(a2.IsNull());
NcGroup b1 = b.AddGroup("b1");
Assert.False(b1.IsNull());
NcGroup b2 = b.AddGroup("b2");
Assert.False(b2.IsNull());
Assert.Equals(file.GetGroupCount(GroupLocation.AllGrps), 7);
Assert.Equals(file.GetGroupCount(GroupLocation.AllChildrenGrps), 6);
Assert.Equals(b2.GetGroupCount(GroupLocation.ParentsGrps), 2);
Assert.Equals(a2.GetGroupCount(GroupLocation.ParentsGrps), 2);
Assert.True(file.GetGroups(GroupLocation.AllChildrenGrps).ContainsKey("b1"));
groups = a1.GetGroups(GroupLocation.ParentsGrps);
Assert.True(groups.ContainsKey("/") && groups["/"].GetId() == file.GetId());
Assert.Equals(file.GetGroups("b1", GroupLocation.AllChildrenGrps).Count, 1);
Assert.True(file.GetGroup("a2", GroupLocation.ChildrenGrps).IsNull());
Assert.Equals(file.GetGroup("a2", GroupLocation.AllChildrenGrps).GetId(), a2.GetId());
Assert.True(file.IsRootGroup());
Assert.False(a.IsRootGroup());
foreach (KeyValuePair <string, NcGroup> group in file.GetGroups(GroupLocation.AllGrps))
{
dim = group.Value.AddDim("time" + (group.Value.IsRootGroup() ? "Root" : group.Key), 20);
NcVar v = group.Value.AddVar("time" + (group.Value.IsRootGroup() ? "Root" : group.Key), NcUint64.Instance, dim);
NcAtt att = group.Value.PutAtt("Attr" + (group.Value.IsRootGroup() ? "Root" : group.Key), "Value");
Assert.False(v.IsNull());
Assert.Equals(file.GetVar(v.GetName(), Location.All).GetId(), v.GetId());
}
Assert.Equals(file.GetVarCount(Location.All), 7);
Assert.Equals(file.GetVars(Location.All).Count, 7);
foreach (KeyValuePair <string, NcVar> gvar in file.GetVars(Location.All))
{
Assert.Equals(gvar.Key, gvar.Value.GetName());
NcGroup g = gvar.Value.GetParentGroup();
Assert.Equals(gvar.Key, "time" + (g.IsRootGroup() ? "Root" : g.GetName()));
}
Assert.Equals(file.GetVars("timeRoot", Location.All).Count, 1);
Assert.Equals(file.GetAttCount(Location.All), 7);
Assert.Equals(file.GetAtts(Location.All).Count, 7);
foreach (KeyValuePair <string, NcGroupAtt> k in file.GetAtts(Location.All))
{
Assert.Equals(k.Value.GetValues(), "Value");
}
} finally {
file.Close();
}
CheckDelete(filePath);
return(true);
}
public bool TestGroupAttributes()
{
NcFile file = null;
NcAtt att = null;
sbyte[] sbyteBuf = new sbyte[2];
byte[] byteBuf = new byte[2];
short[] shortBuf = new short[2];
ushort[] ushortBuf = new ushort[2];
int[] intBuf = new int[2];
uint[] uintBuf = new uint[2];
long[] longBuf = new long[2];
ulong[] ulongBuf = new ulong[2];
float[] floatBuf = new float[2];
double[] doubleBuf = new double[2];
try {
file = TestHelper.NewFile(filePath);
// Test global attributes
att = file.PutAtt("string", "test");
Assert.Equals(att.GetName(), "string");
Assert.Equals(att.GetValues(), "test");
att = file.PutAtt("sbyte", NcByte.Instance, (sbyte)-1);
Assert.Equals(att.GetName(), "sbyte");
att.GetValues(sbyteBuf);
Assert.Equals(sbyteBuf[0], (sbyte)(-1));
att = file.PutAtt("sbyteA", NcByte.Instance, new sbyte[] { -1, 1 });
Assert.Equals(att.GetName(), "sbyteA");
att.GetValues(sbyteBuf);
Assert.Equals(sbyteBuf[1], (sbyte)1);
att = file.PutAtt("byte", NcByte.Instance, (byte)2);
Assert.Equals(att.GetName(), "byte");
att.GetValues(byteBuf);
Assert.Equals(byteBuf[0], (byte)2);
att = file.PutAtt("byteA", NcByte.Instance, new byte[] { 2, 1 });
Assert.Equals(att.GetName(), "byteA");
att.GetValues(byteBuf);
Assert.Equals(byteBuf[1], (byte)1);
att = file.PutAtt("short", NcShort.Instance, (short)-1);
Assert.Equals(att.GetName(), "short");
att.GetValues(shortBuf);
Assert.Equals(shortBuf[0], (short)(-1));
att = file.PutAtt("shortA", NcShort.Instance, new short[] { -1, 1 });
Assert.Equals(att.GetName(), "shortA");
att.GetValues(shortBuf);
Assert.Equals(shortBuf[1], (short)1);
att = file.PutAtt("ushort", NcUshort.Instance, (ushort)2);
Assert.Equals(att.GetName(), "ushort");
att.GetValues(ushortBuf);
Assert.Equals(ushortBuf[0], (ushort)2);
att = file.PutAtt("ushortA", NcUshort.Instance, new ushort[] { 2, 1 });
Assert.Equals(att.GetName(), "ushortA");
att.GetValues(ushortBuf);
Assert.Equals(ushortBuf[1], (ushort)1);
att = file.PutAtt("int", NcInt.Instance, (int)-1);
Assert.Equals(att.GetName(), "int");
att.GetValues(intBuf);
Assert.Equals(intBuf[0], (int)(-1));
att = file.PutAtt("intA", NcInt.Instance, new int[] { -1, 1 });
Assert.Equals(att.GetName(), "intA");
att.GetValues(intBuf);
Assert.Equals(intBuf[1], (int)1);
att = file.PutAtt("uint", NcUint.Instance, (uint)2);
att.GetValues(uintBuf);
Assert.Equals(uintBuf[0], (uint)2);
att = file.PutAtt("uintA", NcUint.Instance, new uint[] { 2, 1 });
att.GetValues(uintBuf);
Assert.Equals(uintBuf[1], (uint)1);
att = file.PutAtt("long", NcInt64.Instance, (long)-1);
att.GetValues(longBuf);
Assert.Equals(longBuf[0], (long)(-1));
att = file.PutAtt("longA", NcInt64.Instance, new long[] { -1, 1 });
att.GetValues(longBuf);
Assert.Equals(longBuf[1], (long)1);
att = file.PutAtt("ulong", NcUint64.Instance, (ulong)2);
att.GetValues(ulongBuf);
Assert.Equals(ulongBuf[0], (ulong)2);
att = file.PutAtt("ulongA", NcUint64.Instance, new ulong[] { 2, 1 });
att.GetValues(ulongBuf);
Assert.Equals(ulongBuf[1], (ulong)1);
att = file.PutAtt("float", NcFloat.Instance, (float)-1);
att.GetValues(floatBuf);
Assert.Equals(floatBuf[0], (float)(-1));
att = file.PutAtt("floatA", NcFloat.Instance, new float[] { -1, 1 });
att.GetValues(floatBuf);
Assert.Equals(floatBuf[1], (float)1);
att = file.PutAtt("double", NcDouble.Instance, (double)2);
att.GetValues(doubleBuf);
Assert.Equals(doubleBuf[0], (double)2);
att = file.PutAtt("doubleA", NcDouble.Instance, new double[] { 2, 1 });
att.GetValues(doubleBuf);
Assert.Equals(doubleBuf[1], (double)1);
} finally {
file.Close();
}
CheckDelete(filePath);
return(true);
}
