public void RoundTripSpecialChars()
{
var dQuote = ValueEncoder.LiteralEscape("\"");
Assert.AreEqual("\"",
ValueEncoder.LiteralUnEscape(dQuote));
}
/// <summary>
/// This implementation assumes no more than one thread is adding regexes, values, or encoders at any given time.
/// </summary>
public void AddValueEncoder(ValueEncoder encoder)
{
ValueSecret[] originalSecrets;
// Read section.
try
{
m_lock.EnterReadLock();
// Test whether already added.
if (m_valueEncoders.Contains(encoder))
{
return;
}
// Read the original value secrets.
originalSecrets = m_originalValueSecrets.ToArray();
}
finally
{
if (m_lock.IsReadLockHeld)
{
m_lock.ExitReadLock();
}
}
// Compute the encoded values.
var encodedSecrets = new List <ValueSecret>();
foreach (ValueSecret originalSecret in originalSecrets)
{
String encodedValue = encoder(originalSecret.m_value);
if (!String.IsNullOrEmpty(encodedValue))
{
encodedSecrets.Add(new ValueSecret(encodedValue));
}
}
// Write section.
try
{
m_lock.EnterWriteLock();
// Add the encoder.
m_valueEncoders.Add(encoder);
// Add the values.
foreach (ValueSecret encodedSecret in encodedSecrets)
{
m_valueSecrets.Add(encodedSecret);
}
}
finally
{
if (m_lock.IsWriteLockHeld)
{
m_lock.ExitWriteLock();
}
}
}
/// <summary>
/// Overloading of AddValueEncoder method with additional logic for logging origin of provided secret
/// </summary>
/// <param name="encoder"></param>
/// <param name="origin"></param>
public void AddValueEncoder(ValueEncoder encoder, string origin)
{
this.Trace($"Setting up value for origin: {origin}");
this.Trace($"Length: {encoder.ToString().Length}.");
if (encoder == null)
{
this.Trace($"Encoder is empty.");
return;
}
AddValueEncoder(encoder);
}
public static string Encode(Value array)
{
if (!Values.isArrayValue(array))
{
throw new System.ArgumentException("Only works with arrays");
}
ValueEncoder encoder = new ValueEncoder();
array.WriteTo(encoder);
return(encoder.Result());
}
public void ReadEscapedLiteral()
{
var data = "\\\""; //== \"
var expected = "\"";
var literal = "\"" + data + "\"";
var token = NTripleTokenizer.NextToken(literal).Value;
Assert.AreEqual('\\', token[0]);
Assert.AreEqual('"', token[1]);
Assert.AreEqual(2, token.Length);
var result = ValueEncoder.LiteralUnEscape(token);
Assert.AreEqual(expected, result,
"Preserve and skip escaped");
}
public void AddValueEncoder(ValueEncoder encoder)
{
this._secretMasker.AddValueEncoder(encoder);
}
public void HexChars()
{
var bang = ValueEncoder.LiteralUnEscape("\u0021");
Assert.AreEqual("!", bang);
}
private static void InitClassEncoder <T>(ValueEncoder <T> encoder) where T : class
{
valueEncoders.TryAdd(typeof(T), new NullEncoder <T>(encoder));
}
public ParametrizedOption WithEncoder(ValueEncoder encoder)
{
Encoder = encoder;
return(this);
}
private static void InitStructEncoder <T>(ValueEncoder <T> encoder) where T : struct
{
valueEncoders.TryAdd(typeof(T), encoder);
valueEncoders.TryAdd(typeof(T?), new NullableEncoder <T>(encoder));
}
public NullEncoder(ValueEncoder <T> valueEncoder)
{
this.valueEncoder = valueEncoder;
}
public MemberEncoder(EncodingMember <TInstance, TMember> member)
{
this.member = member;
this.valueEncoder = GetEncoder <TMember>();
}
public EnumerableEncoder()
{
this.elementEncoder = GetEncoder <TElem>();
}
public DictionaryEncoder()
{
this.valueEncoder = (ValueEncoder <V>)GetEncoder(typeof(V));
}