public void TestSavePersistent()
{
string key1 = "key1";
string toWrite1 = "val1";
NtCore.SetEntryValue(key1, Value.MakeString(toWrite1));
NtCore.SetEntryFlags(key1, EntryFlags.Persistent);
string key2 = "key2";
NtCore.SetEntryValue(key2, Value.MakeBoolean(true));
NtCore.SetEntryFlags(key2, EntryFlags.Persistent);
string fileName = "testfile.txt";
if (File.Exists(fileName))
{
File.Delete(fileName);
}
NtCore.SavePersistent(fileName);
string[] lines = File.ReadAllLines(fileName);
Assert.That(lines.Length, Is.GreaterThanOrEqualTo(3));
Assert.That(lines[0], Contains.Substring("[NetworkTables Storage 3.0]"));
Assert.That(lines[1], Contains.Substring($"string \"{key1}\"=\"{toWrite1}\""));
Assert.That(lines[2], Contains.Substring($"boolean \"{key2}\"=true"));
}
public void FixtureSetUp()
{
NtCore.SetLogger((level, file, line, msg) =>
{
Console.WriteLine(msg);
}, LogLevel.LogInfo);
}
public void TestGetEntriesOnlyString()
{
string key1 = "testKey";
string toWrite1 = "written";
NtCore.SetEntryValue(key1, Value.MakeString(toWrite1));
string key2 = "testKey2";
double toWrite2 = 3.58;
NtCore.SetEntryValue(key2, Value.MakeDouble(toWrite2));
string key3 = "testKey3";
bool toWrite3 = true;
NtCore.SetEntryValue(key3, Value.MakeBoolean(toWrite3));
Thread.Sleep(20);
var entries = NtCore.GetEntryInfo("", NtType.String);
Assert.That(1, Is.EqualTo(entries.Count));
Assert.That(entries[0].Name, Is.EqualTo(key1));
Assert.That(entries[0].Type, Is.EqualTo(NtType.String));
Assert.That(entries[0].Flags, Is.EqualTo(EntryFlags.None));
Assert.That(entries[0].LastChange, Is.GreaterThan(0));
}
public void TestPersistentLoadError()
{
const string key1 = "key1";
const string key2 = "key2";
const string val1 = "val1";
string[] toWrite = new[]
{
"[NetworkTables Storage 3.0]",
$"string \"{key1}\"=\"{val1}\"",
$"boolean \"{key2}\"=invalid",
""
};
string fileName = "testfile.txt";
if (File.Exists(fileName))
{
File.Delete(fileName);
}
File.WriteAllLines(fileName, toWrite);
string[] errors = NtCore.LoadPersistent(fileName);
Assert.That(errors.Length, Is.EqualTo(1));
Assert.That(errors[0], Contains.Substring("3: unrecognized boolean value, not 'true' or 'false'"));
}
public void TestLoadPersistent()
{
const string key1 = "key1";
const string key2 = "key2";
const string val1 = "val1";
string[] toWrite = new[]
{
"[NetworkTables Storage 3.0]",
$"string \"{key1}\"=\"{val1}\"",
$"boolean \"{key2}\"=true",
""
};
string fileName = "testfile.txt";
if (File.Exists(fileName))
{
File.Delete(fileName);
}
File.WriteAllLines(fileName, toWrite);
string[] errors = NtCore.LoadPersistent(fileName);
Assert.That(errors.Length, Is.EqualTo(0));
var entries = CoreMethods.GetEntryInfo("", 0);
Assert.That(entries.Count, Is.EqualTo(2));
Assert.That(CoreMethods.GetEntryString(key1, ""), Is.EqualTo(val1));
Assert.That(CoreMethods.GetEntryBoolean(key2, false), Is.EqualTo(true));
}
public static void DeleteAllWithPersistent()
{
foreach (var entryInfo in NtCore.GetEntryInfo("", 0))
{
NtCore.DeleteEntry(entryInfo.Name);
}
}
public void TestContainsKeySuccess()
{
string key1 = "testKey";
string toWrite1 = "written";
NtCore.SetEntryValue(key1, Value.MakeString(toWrite1));
Assert.That(NtCore.ContainsEntry(key1));
}
public void TestGetTypeSuccess()
{
string key1 = "testKey";
string toWrite1 = "written";
NtCore.SetEntryValue(key1, Value.MakeString(toWrite1));
Assert.That(NtCore.GetType(key1), Is.EqualTo(NtType.String));
}
/// <inheritdoc cref="NtCore.GetEntryBooleanArray(string)"/>
public bool[] GetEntryBooleanArray(string name)
{
var v = m_storage.GetEntryValue(name);
if (v == null || !v.IsBooleanArray())
{
throw NtCore.GetValueException(name, v, NtType.BooleanArray);
}
return(v.GetBooleanArray());
}
/// <inheritdoc cref="NtCore.GetEntryDoubleArray(string)"/>
public double[] GetEntryDoubleArray(string name)
{
var v = m_storage.GetEntryValue(name);
if (v == null || !v.IsDoubleArray())
{
throw NtCore.GetValueException(name, v, NtType.DoubleArray);
}
return(v.GetDoubleArray());
}
/// <inheritdoc cref="NtCore.GetEntryStringArray(string)"/>
public string[] GetEntryStringArray(string name)
{
var v = m_storage.GetEntryValue(name);
if (v == null || !v.IsStringArray())
{
throw NtCore.GetValueException(name, v, NtType.StringArray);
}
return(v.GetStringArray());
}
/// <inheritdoc cref="NtCore.GetEntryRaw(string)"/>
public byte[] GetEntryRaw(string name)
{
var v = m_storage.GetEntryValue(name);
if (v == null || !v.IsRaw())
{
throw NtCore.GetValueException(name, v, NtType.Raw);
}
return(v.GetRaw());
}
public void TestAddRemoveConnectionListener()
{
ConnectionListenerCallback callback = (uid, connected, conn) =>
{
};
int id = NtCore.AddConnectionListener(callback, true);
Assert.That(id, Is.Not.EqualTo(0));
NtCore.RemoveEntryListener(id);
}
public void TestAddEntryListener()
{
string key1 = "testKey";
string toWrite1 = "written";
NtCore.SetEntryValue(key1, Value.MakeString(toWrite1));
int count = 0;
string recievedKey = "";
Value recievedValue = null;
NotifyFlags receivedFlags = 0;
NotifyFlags f = NotifyFlags.NotifyNew | NotifyFlags.NotifyUpdate;
if (true)
{
f |= NotifyFlags.NotifyLocal;
}
int listener = NtCore.AddEntryListener(key1, (uid, key, value, flags) =>
{
count++;
recievedKey = key;
recievedValue = value;
receivedFlags = flags;
}, f);
string toWrite2 = "NewNumber";
NtCore.SetEntryValue(key1, Value.MakeString(toWrite2));
Thread.Sleep(20);
Assert.That(count, Is.GreaterThanOrEqualTo(1));
Assert.That(recievedKey, Is.EqualTo(key1));
Assert.That(recievedValue, Is.Not.Null);
Assert.That(recievedValue.IsString);
var retValue = recievedValue.GetString();
Assert.That(retValue, Is.Not.Null);
Assert.That(retValue, Is.EqualTo(toWrite2));
Assert.That(receivedFlags.HasFlag(NotifyFlags.NotifyLocal));
NtCore.RemoveEntryListener(listener);
}
public void TestGetEntryFlags()
{
string key = "testKey";
NtCore.SetEntryValue(key, Value.MakeString("value"));
EntryFlags flags = NtCore.GetEntryFlags(key);
Assert.That(flags, Is.EqualTo(EntryFlags.None));
NtCore.SetEntryFlags(key, EntryFlags.Persistent);
flags = NtCore.GetEntryFlags(key);
Assert.That(flags, Is.EqualTo(EntryFlags.Persistent));
}
/// <summary>
/// Initializes the singleton application object. This is the first line of authored code
/// executed, and as such is the logical equivalent of main() or WinMain().
/// </summary>
public App()
{
this.InitializeComponent();
NtCoreHelper.LoadOnStaticInit = false;
try
{
NtCore.LoadExisting(new NtCorePlatform());
}
catch (Exception ex)
{
throw ex;
}
this.Suspending += OnSuspending;
}
public void TestEntryListenerBooleanArray()
{
string key1 = "testKey";
bool[] toWrite1 = { true, true, true };
NtCore.SetEntryValue(key1, Value.MakeBooleanArray(toWrite1));
int count = 0;
string recievedKey = "";
Value recievedValue = null;
NotifyFlags receivedFlags = 0;
NotifyFlags f = NotifyFlags.NotifyNew | NotifyFlags.NotifyUpdate;
if (true)
{
f |= NotifyFlags.NotifyImmediate;
}
int listener = NtCore.AddEntryListener(key1, (uid, key, value, flags) =>
{
count++;
recievedKey = key;
recievedValue = value;
receivedFlags = flags;
}, f);
Thread.Sleep(300);
Assert.That(count, Is.EqualTo(1));
Assert.That(recievedKey, Is.EqualTo(key1));
Assert.That(recievedValue, Is.Not.Null);
Assert.That(recievedValue.IsBooleanArray());
bool[] retValue = recievedValue.GetBooleanArray();
for (int i = 0; i < retValue.Length; i++)
{
Assert.That(retValue[i], Is.EqualTo(toWrite1[i]));
}
Assert.That(receivedFlags.HasFlag(NotifyFlags.NotifyImmediate));
NtCore.RemoveEntryListener(listener);
}
public void TestDeleteEntry()
{
string key1 = "testKey";
string toWrite1 = "written";
NtCore.SetEntryValue(key1, Value.MakeString(toWrite1));
string key2 = "testKey2";
double toWrite2 = 3.58;
NtCore.SetEntryValue(key2, Value.MakeDouble(toWrite2));
Assert.That(NtCore.GetEntryInfo("", 0).Count, Is.EqualTo(2));
NtCore.DeleteEntry(key1);
Assert.That(NtCore.GetEntryInfo("", 0).Count, Is.EqualTo(1));
Assert.That(NtCore.GetEntryValue(key1), Is.Null);
}
static void Main(string[] args)
{
NtCore.Initialize();
NetworkTableInstance instance = NetworkTableInstance.Default;
GC.KeepAlive(instance);
//var i = SendableRegistry.Instance;
//var map = new ConditionalWeakTable<HolderMethod, Container>();
//var holder = new HolderMethod();
//map.Add(holder, new Container(holder));
////holder = null;
////while (map.Any())
////{
//// //Console.WriteLine(map.Count());
//// GC.Collect();
////}
//RobotBase.StartRobot<Robot>();
}
private CameraServer()
{
m_defaultUsbDevice = 0;
m_lockObject = new object();
m_sources = new Dictionary <string, VideoSource>();
m_sinks = new Dictionary <string, VideoSink>();
m_tables = new Dictionary <int, ITable>();
m_publishTable = NetworkTable.GetTable(PublishName);
m_nextPort = BasePort;
m_addresses = new List <string>();
m_videoListener = new VideoListener((vidEvent) =>
{
switch (vidEvent.Kind)
{
case EventKind.SourceCreated:
{
// Create subtable for the camera
ITable table = m_publishTable.GetSubTable(vidEvent.Name);
lock (m_lockObject)
{
m_tables.Add(vidEvent.SourceHandle, table);
}
table.PutString("source", MakeSourceValue(vidEvent.SourceHandle));
table.PutString("description",
NativeMethods.GetSourceDescription(vidEvent.SourceHandle));
table.PutBoolean("connected", NativeMethods.IsSourceConnected(vidEvent.SourceHandle));
table.PutStringArray("streams", GetSourceStreamValues(vidEvent.SourceHandle));
try
{
VideoMode mode = NativeMethods.GetSourceVideoMode(vidEvent.SourceHandle);
table.SetDefaultString("mode", VideoModeToString(mode));
table.PutStringArray("modes", GetSourceModeValues(vidEvent.SourceHandle));
}
catch (VideoException)
{
// Do nothing
}
break;
}
case EventKind.SourceDestroyed:
{
ITable table = GetSourceTable(vidEvent.SourceHandle);
if (table != null)
{
table.PutString("source", "");
table.PutStringArray("streams", new string[0]);
table.PutStringArray("modes", new string[0]);
}
break;
}
case EventKind.SourceConnected:
{
ITable table = GetSourceTable(vidEvent.SourceHandle);
if (table != null)
{
// update the description too (as it may have changed)
table.PutString("description",
NativeMethods.GetSourceDescription(vidEvent.SourceHandle));
table.PutBoolean("connected", true);
}
break;
}
case EventKind.SourceDisconnected:
{
ITable table = GetSourceTable(vidEvent.SourceHandle);
table?.PutBoolean("connected", false);
break;
}
case EventKind.SourceVideoModesUpdated:
{
ITable table = GetSourceTable(vidEvent.SourceHandle);
if (table != null)
{
table.PutStringArray("modes", GetSourceModeValues(vidEvent.SourceHandle));
}
break;
}
case EventKind.SourceVideoModeChanged:
{
ITable table = GetSourceTable(vidEvent.SourceHandle);
if (table != null)
{
table.PutString("mode", VideoModeToString(vidEvent.Mode));
}
break;
}
case EventKind.SourcePropertyCreated:
{
ITable table = GetSourceTable(vidEvent.SourceHandle);
if (table != null)
{
PutSourcePropertyValue(table, vidEvent, true);
}
break;
}
case EventKind.SourcePropertyValueUpdated:
{
ITable table = GetSourceTable(vidEvent.SourceHandle);
if (table != null)
{
PutSourcePropertyValue(table, vidEvent, false);
}
break;
}
case EventKind.SourcePropertyChoicesUpdated:
{
ITable table = GetSourceTable(vidEvent.SourceHandle);
if (table != null)
{
List <string> choices = NativeMethods.GetEnumPropertyChoices(vidEvent.PropertyHandle);
table.PutStringArray($"PropertyInfo/{vidEvent.Name}/choices", choices);
}
break;
}
case EventKind.SinkSourceChanged:
case EventKind.SinkCreated:
case EventKind.SinkDestroyed:
{
UpdateStreamValues();
break;
}
case EventKind.NetworkInterfacesChanged:
{
m_addresses = NativeMethods.GetNetworkInterfaces();
break;
}
default:
break;
}
}, (EventKind)0x4fff, true);
m_tableListener = NtCore.AddEntryListener($"{PublishName}/", (uid, key, value, flags) =>
{
string relativeKey = key.Substring(PublishName.Length + 1);
int subKeyIndex = relativeKey.IndexOf('/');
if (subKeyIndex == -1)
{
return;
}
string sourceName = relativeKey.Substring(0, subKeyIndex);
VideoSource source;
if (!m_sources.TryGetValue(sourceName, out source))
{
return;
}
relativeKey = relativeKey.Substring(subKeyIndex + 1);
string propName;
if (relativeKey == "mode")
{
// reset to current mode
NtCore.SetEntryString(key, VideoModeToString(source.GetVideoMode()));
return;
}
else if (relativeKey.StartsWith("Property/"))
{
propName = relativeKey.Substring(9);
}
else if (relativeKey.StartsWith("RawProperty/"))
{
propName = relativeKey.Substring(12);
}
else
{
return;
}
VideoProperty prop = source.GetProperty(propName);
switch (prop.Kind)
{
case PropertyKind.None:
return;
case PropertyKind.Boolean:
NtCore.SetEntryBoolean(key, prop.Get() != 0);
break;
case PropertyKind.Integer:
case PropertyKind.Enum:
NtCore.SetEntryDouble(key, prop.Get());
break;
case PropertyKind.String:
NtCore.SetEntryString(key, prop.GetString());
break;
default:
return;
}
}, NotifyFlags.NotifyImmediate | NotifyFlags.NotifyUpdate);
}
public void FixtureTearDown()
{
NtCore.StopRpcServer();
}
public void TestGetTypeNonExistentKey()
{
Assert.That(NtCore.GetType("testKey"), Is.EqualTo(NtType.Unassigned));
}
public void TestContainsKeyNonExistentKey()
{
Assert.That(!NtCore.ContainsEntry("testKey"));
}
public void FixtureTearDown()
{
NtCore.StopNotifier();
}
public void TestAddEntryListenerDefaultTypes(object val)
{
string key1 = "testKey";
if (val is double)
{
NtCore.SetEntryValue(key1, Value.MakeDouble((double)val));
}
else if (val is bool)
{
NtCore.SetEntryValue(key1, Value.MakeBoolean((bool)val));
}
else if (val is string)
{
NtCore.SetEntryValue(key1, Value.MakeString((string)val));
}
int count = 0;
string recievedKey = "";
Value recievedValue = null;
NotifyFlags receivedFlags = 0;
NotifyFlags f = NotifyFlags.NotifyNew | NotifyFlags.NotifyUpdate;
if (true)
{
f |= NotifyFlags.NotifyImmediate;
}
int listener = NtCore.AddEntryListener(key1, (uid, key, value, flags) =>
{
count++;
recievedKey = key;
recievedValue = value;
receivedFlags = flags;
}, f);
Thread.Sleep(20);
Assert.That(count, Is.EqualTo(1));
Assert.That(recievedKey, Is.EqualTo(key1));
Assert.That(recievedValue, Is.Not.Null);
if (val is double)
{
Assert.That(recievedValue.IsDouble());
var retValue = recievedValue.GetDouble();
Assert.That(retValue, Is.EqualTo((double)val));
Assert.That(receivedFlags.HasFlag(NotifyFlags.NotifyImmediate));
}
else if (val is bool)
{
Assert.That(recievedValue.IsBoolean());
var retValue = recievedValue.GetBoolean();
Assert.That(retValue, Is.EqualTo((bool)val));
Assert.That(receivedFlags.HasFlag(NotifyFlags.NotifyImmediate));
}
else if (val is string)
{
Assert.That(recievedValue.IsString);
var retValue = recievedValue.GetString();
Assert.That(retValue, Is.Not.Null);
Assert.That(retValue, Is.EqualTo((string)val));
Assert.That(receivedFlags.HasFlag(NotifyFlags.NotifyImmediate));
}
else
{
NtCore.RemoveEntryListener(listener);
Assert.Fail("Unknown type");
return;
}
NtCore.RemoveEntryListener(listener);
}
public void TestSetNetworkIdentity()
{
NtCore.SetNetworkIdentity("UnitTests");
Assert.Pass();
}
public void TestFlush()
{
NtCore.Flush();
Assert.Pass();
}
public void TestNow()
{
Assert.That(NtCore.Now(), Is.GreaterThan(0));
}
public void TestSetUpdateRate()
{
NtCore.SetUpdateRate(100);
Assert.Pass();
}
public void TestGetConnections()
{
var connection = NtCore.GetConnections();
Assert.That(connection.Count, Is.EqualTo(0));
}
