Mexican food usually dominates the menus of restaurants in California. However, Glendale dining reflects that it is the home to the largest Armenian population in the United States. Armenian restaurants in Glendale make up a significant part of the dining in Glendale.
Several Armenian restaurants in Glendale practice outdoor grilling of Armenian ethnic food. The aroma delights the senses and tempts every passerby who passes near the ubiquitous Armenian restaurants in Glendale.
The influx of recent immigrants from different countries has brought several authentic cultural cuisine opportunities for dining in Glendale restaurants. Several great ethnic options for dining in Glendale restaurants include Chinese, Cuban, Italian Delis, Iranian, Korean, Lebanese, and Mexican, all within the confines of the downtown area.
Downtown Glendale hosts two large shopping malls in Glendale Galleria and Americana at Brand. As such, downtown Glendale is known for its fabulous Glendale dining, terrific shopping and friendly atmosphere. Glendale Galleria was built in 1976 and is the second largest mall in Los Angeles County. The Galleria is anchored by the world-famous Alex Theatre, and is home to 5 department stores and over 220 shops and Glendale restaurants.
Americana at Brand is a 15.5 acre outdoor shopping and residential community that just opened in 2008. It hosts over 75 shops and restaurants in Glendale as well as an 18-plex cinema.
As a whole, the downtown area hosts over 300 shops and restaurants in Glendale, making for a dizzying array of gastronomic feast. There are also weekly farmer's market, concerts, and festivals that are regularly held in downtown Glendale.
As with the rest of Southern California, Glendale enjoys a mild Mediterranean climate with an average high temperature of 77 degrees. During the fall and winter months the unique Santa Ana wind conditions affect the local weather and bring warm dry air from the northeast, which results in a temperate climate.
Outdoor Glendale dining, whether on an outdoor patio in a Glendale restaurant or a home packed picnic, is a wonderful experience sure to satisfy all five senses. There are many outdoor activities to further enjoy your Glendale dining experience.
There are a lot of recreational activities available in Glendale. A large number of parks in Glendale offer everything from baseball diamonds to skateboard ramps, as well as mountain hikes and nature trails that offer a scenic view of the Greater Los Angeles area.
Glendale is a suburb in the greater Los Angeles area, with a population of about 200,000, making it the third largest city in Los Angeles County. Despite its urban location, Glendale still maintains a small town charm and warm hospitality. Glendale sits at the foot of the Verdugo Mountains and has an ethnically diverse population.
The City of Glendale is the home of the now defunct Grand Central Airport, which is recognized for its contribution to the emerging age of aviation in the United States. The City saw significant development during the 1970's and is now the home to several large companies. Today, Glendale is the home of several large multinationals including Nestle, Disney and Dreamworks SKG.


Release the BEAST! Finally after years, TBS has a new website! This little monster has been set up to allow both artist and clients of Trouble Bound Studio easier access to the latest information, tattoos, videos and what ever else cross's our minds to be available at just one touch! Like all projects, this is a work in progress and it will grow by leaps and bounds as the shop moves forward. With that being said, we must thank the hard work of Brad Wilkins for his tireless work dealing with a computer illiterate to make this project happen.
Hopefully you enjoy our latest toy and we look forward to hearing from you….


Yet another Malabar delicacy which is known for its taste and flavor. Here lamb or mutton is cooked with little spices and then sauteed along with the onion gravy, the traditional way of making lamb biryani. The stock water after cooking mutton is used for cooking rice which makes this biryani a drooling taste. Hope you all give this lamb recipe a try.
Marinate the mutton with all the ingredients, as above given for the marination. Keep it refrigerated for 2 hours.
Then put the mutton in a cooker and pressure cook it for 3 whistles.
When it is done and the pressure settled down, open the lid and drain the water to a bowl and keep a half cup of the stock water separately.
Keep aside the mutton and water in a separate bowl.
Now the next step is boiling the rice. So take a vessel and add the stock water drained from cooked mutton (water must be more than double the amount of rice. so u can add extra normal water if the stock is not enough.
When it starts boiling, add vinegar and 1 tbsp oil to it and close the lid.
Now drain the water in the rice and keep the rice aside in a colander.
Again heat ghee in a deep bottomed vessel.
Saute well, when done add the cooked mutton along with half cup of stock and close the lid.
Allow it to cook for few minutes and then open the lid and again cook for another 5 minutes to get a thick gravy.
Now add salt, mint and coriander leaves. Mix well.
Now drop some boiled rice over the masala, then spread chopped coriander leaves and some drops of ghee. Again layer the rice and repeat it. This process is called Dum.
Finally, garnish with coriander leaves and spread some ghee on the top evenly.
Close the lid tightly and can keep some weight over the vessel (optional). Or can close all the ends of the vessels with maida (All purpose flour) dough.
Allow it to cook on very low flame for 30 minutes.
While serving garnish with fried cashews ,raisins, and fried onion.


text:
#region Copyright notice and license
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc.  All rights reserved.
// https://developers.google.com/protocol-buffers/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#endregion

using Google.Protobuf.Reflection;
using Google.Protobuf.TestProtos;
using Google.Protobuf.WellKnownTypes;
using NUnit.Framework;
using ProtobufTestMessages.Proto2;
using System;
using UnitTest.Issues.TestProtos;

namespace Google.Protobuf
{
    /// <summary>
    /// Unit tests for JSON parsing.
    /// </summary>
    public class JsonParserTest
    {
        // Sanity smoke test
        [Test]
        public void AllTypesRoundtrip()
        {
            AssertRoundtrip(SampleMessages.CreateFullTestAllTypes());
        }

        [Test]
        public void Maps()
        {
            AssertRoundtrip(new TestMap { MapStringString = { { "with spaces", "bar" }, { "a", "b" } } });
            AssertRoundtrip(new TestMap { MapInt32Int32 = { { 0, 1 }, { 2, 3 } } });
            AssertRoundtrip(new TestMap { MapBoolBool = { { false, true }, { true, false } } });
        }

        [Test]
        [TestCase(" 1 ")]
        [TestCase("+1")]
        [TestCase("1,000")]
        [TestCase("1.5")]
        public void IntegerMapKeysAreStrict(string keyText)
        {
            // Test that integer parsing is strict. We assume that if this is correct for int32,
            // it's correct for other numeric key types.
            var json = "{ \"mapInt32Int32\": { \"" + keyText + "\" : \"1\" } }";
            Assert.Throws<InvalidProtocolBufferException>(() => JsonParser.Default.Parse<TestMap>(json));
        }

        [Test]
        public void OriginalFieldNameAccepted()
        {
            var json = "{ \"single_int32\": 10 }";
            var expected = new TestAllTypes { SingleInt32 = 10 };
            Assert.AreEqual(expected, TestAllTypes.Parser.ParseJson(json));
        }

        [Test]
        public void SourceContextRoundtrip()
        {
            AssertRoundtrip(new SourceContext { FileName = "foo.proto" });
        }

        [Test]
        public void SingularWrappers_DefaultNonNullValues()
        {
            var message = new TestWellKnownTypes
            {
                StringField = "",
                BytesField = ByteString.Empty,
                BoolField = false,
                FloatField = 0f,
                DoubleField = 0d,
                Int32Field = 0,
                Int64Field = 0,
                Uint32Field = 0,
                Uint64Field = 0
            };
            AssertRoundtrip(message);
        }

        [Test]
        public void SingularWrappers_NonDefaultValues()
        {
            var message = new TestWellKnownTypes
            {
                StringField = "x",
                BytesField = ByteString.CopyFrom(1, 2, 3),
                BoolField = true,
                FloatField = 12.5f,
                DoubleField = 12.25d,
                Int32Field = 1,
                Int64Field = 2,
                Uint32Field = 3,
                Uint64Field = 4
            };
            AssertRoundtrip(message);
        }

        [Test]
        public void SingularWrappers_ExplicitNulls()
        {
            // When we parse the "valueField": null part, we remember it... basically, it's one case
            // where explicit default values don't fully roundtrip.
            var message = new TestWellKnownTypes { ValueField = Value.ForNull() };
            var json = new JsonFormatter(new JsonFormatter.Settings(true)).Format(message);
            var parsed = JsonParser.Default.Parse<TestWellKnownTypes>(json);
            Assert.AreEqual(message, parsed);
        }

        [Test]
        [TestCase(typeof(BoolValue), "true", true)]
        [TestCase(typeof(Int32Value), "32", 32)]
        [TestCase(typeof(Int64Value), "32", 32L)]
        [TestCase(typeof(Int64Value), "\"32\"", 32L)]
        [TestCase(typeof(UInt32Value), "32", 32U)]
        [TestCase(typeof(UInt64Value), "\"32\"", 32UL)]
        [TestCase(typeof(UInt64Value), "32", 32UL)]
        [TestCase(typeof(StringValue), "\"foo\"", "foo")]
        [TestCase(typeof(FloatValue), "1.5", 1.5f)]
        [TestCase(typeof(DoubleValue), "1.5", 1.5d)]
        public void Wrappers_Standalone(System.Type wrapperType, string json, object expectedValue)
        {
            IMessage parsed = (IMessage)Activator.CreateInstance(wrapperType);
            IMessage expected = (IMessage)Activator.CreateInstance(wrapperType);
            JsonParser.Default.Merge(parsed, "null");
            Assert.AreEqual(expected, parsed);

            JsonParser.Default.Merge(parsed, json);
            expected.Descriptor.Fields[WrappersReflection.WrapperValueFieldNumber].Accessor.SetValue(expected, expectedValue);
            Assert.AreEqual(expected, parsed);
        }

        [Test]
        public void ExplicitNullValue()
        {
            string json = "{\"valueField\": null}";
            var message = JsonParser.Default.Parse<TestWellKnownTypes>(json);
            Assert.AreEqual(new TestWellKnownTypes { ValueField = Value.ForNull() }, message);
        }

        [Test]
        public void BytesWrapper_Standalone()
        {
            ByteString data = ByteString.CopyFrom(1, 2, 3);
            // Can't do this with attributes...
            var parsed = JsonParser.Default.Parse<BytesValue>(WrapInQuotes(data.ToBase64()));
            var expected = new BytesValue { Value = data };
            Assert.AreEqual(expected, parsed);
        }

        [Test]
        public void RepeatedWrappers()
        {
            var message = new RepeatedWellKnownTypes
            {
                BoolField = { true, false },
                BytesField = { ByteString.CopyFrom(1, 2, 3), ByteString.CopyFrom(4, 5, 6), ByteString.Empty },
                DoubleField = { 12.5, -1.5, 0d },
                FloatField = { 123.25f, -20f, 0f },
                Int32Field = { int.MaxValue, int.MinValue, 0 },
                Int64Field = { long.MaxValue, long.MinValue, 0L },
                StringField = { "First", "Second", "" },
                Uint32Field = { uint.MaxValue, uint.MinValue, 0U },
                Uint64Field = { ulong.MaxValue, ulong.MinValue, 0UL },
            };
            AssertRoundtrip(message);
        }

        [Test]
        public void RepeatedField_NullElementProhibited()
        {
            string json = "{ \"repeated_foreign_message\": [null] }";
            Assert.Throws<InvalidProtocolBufferException>(() => TestAllTypes.Parser.ParseJson(json));
        }

        [Test]
        public void RepeatedField_NullOverallValueAllowed()
        {
            string json = "{ \"repeated_foreign_message\": null }";
            Assert.AreEqual(new TestAllTypes(), TestAllTypes.Parser.ParseJson(json));
        }

        [Test]
        [TestCase("{ \"mapInt32Int32\": { \"10\": null }")]
        [TestCase("{ \"mapStringString\": { \"abc\": null }")]
        [TestCase("{ \"mapInt32ForeignMessage\": { \"10\": null }")]
        public void MapField_NullValueProhibited(string json)
        {
            Assert.Throws<InvalidProtocolBufferException>(() => TestMap.Parser.ParseJson(json));
        }

        [Test]
        public void MapField_NullOverallValueAllowed()
        {
            string json = "{ \"mapInt32Int32\": null }";
            Assert.AreEqual(new TestMap(), TestMap.Parser.ParseJson(json));
        }

        [Test]
        public void IndividualWrapperTypes()
        {
            Assert.AreEqual(new StringValue { Value = "foo" }, StringValue.Parser.ParseJson("\"foo\""));
            Assert.AreEqual(new Int32Value { Value = 1 }, Int32Value.Parser.ParseJson("1"));
            // Can parse strings directly too
            Assert.AreEqual(new Int32Value { Value = 1 }, Int32Value.Parser.ParseJson("\"1\""));
        }

        private static void AssertRoundtrip<T>(T message) where T : IMessage<T>, new()
        {
            var clone = message.Clone();
            var json = JsonFormatter.Default.Format(message);
            var parsed = JsonParser.Default.Parse<T>(json);
            Assert.AreEqual(clone, parsed);
        }

        [Test]
        [TestCase("0", 0)]
        [TestCase("-0", 0)] // Not entirely clear whether we intend to allow this...
        [TestCase("1", 1)]
        [TestCase("-1", -1)]
        [TestCase("2147483647", 2147483647)]
        [TestCase("-2147483648", -2147483648)]
        public void StringToInt32_Valid(string jsonValue, int expectedParsedValue)
        {
            string json = "{ \"singleInt32\": \"" + jsonValue + "\"}";
            var parsed = TestAllTypes.Parser.ParseJson(json);
            Assert.AreEqual(expectedParsedValue, parsed.SingleInt32);
        }

        [Test]
        [TestCase("+0")]
        [TestCase(" 1")]
        [TestCase("1 ")]
        [TestCase("00")]
        [TestCase("-00")]
        [TestCase("--1")]
        [TestCase("+1")]
        [TestCase("1.5")]
        [TestCase("1e10")]
        [TestCase("2147483648")]
        [TestCase("-2147483649")]
        public void StringToInt32_Invalid(string jsonValue)
        {
            string json = "{ \"singleInt32\": \"" + jsonValue + "\"}";
            Assert.Throws<InvalidProtocolBufferException>(() => TestAllTypes.Parser.ParseJson(json));
        }

        [Test]
        [TestCase("0", 0U)]
        [TestCase("1", 1U)]
        [TestCase("4294967295", 4294967295U)]
        public void StringToUInt32_Valid(string jsonValue, uint expectedParsedValue)
        {
            string json = "{ \"singleUint32\": \"" + jsonValue + "\"}";
            var parsed = TestAllTypes.Parser.ParseJson(json);
            Assert.AreEqual(expectedParsedValue, parsed.SingleUint32);
        }

        // Assume that anything non-bounds-related is covered in the Int32 case
        [Test]
        [TestCase("-1")]
        [TestCase("4294967296")]
        public void StringToUInt32_Invalid(string jsonValue)
        {
            string json = "{ \"singleUint32\": \"" + jsonValue + "\"}";
            Assert.Throws<InvalidProtocolBufferException>(() => TestAllTypes.Parser.ParseJson(json));
        }

        [Test]
        [TestCase("0", 0L)]
        [TestCase("1", 1L)]
        [TestCase("-1", -1L)]
        [TestCase("9223372036854775807", 9223372036854775807)]
        [TestCase("-9223372036854775808", -9223372036854775808)]
        public void StringToInt64_Valid(string jsonValue, long expectedParsedValue)
        {
            string json = "{ \"singleInt64\": \"" + jsonValue + "\"}";
            var parsed = TestAllTypes.Parser.ParseJson(json);
            Assert.AreEqual(expectedParsedValue, parsed.SingleInt64);
        }

        // Assume that anything non-bounds-related is covered in the Int32 case
        [Test]
        [TestCase("-9223372036854775809")]
        [TestCase("9223372036854775808")]
        public void StringToInt64_Invalid(string jsonValue)
        {
            string json = "{ \"singleInt64\": \"" + jsonValue + "\"}";
            Assert.Throws<InvalidProtocolBufferException>(() => TestAllTypes.Parser.ParseJson(json));
        }

        [Test]
        [TestCase("0", 0UL)]
        [TestCase("1", 1UL)]
        [TestCase("18446744073709551615", 18446744073709551615)]
        public void StringToUInt64_Valid(string jsonValue, ulong expectedParsedValue)
        {
            string json = "{ \"singleUint64\": \"" + jsonValue + "\"}";
            var parsed = TestAllTypes.Parser.ParseJson(json);
            Assert.AreEqual(expectedParsedValue, parsed.SingleUint64);
        }

        // Assume that anything non-bounds-related is covered in the Int32 case
        [Test]
        [TestCase("-1")]
        [TestCase("18446744073709551616")]
        public void StringToUInt64_Invalid(string jsonValue)
        {
            string json = "{ \"singleUint64\": \"" + jsonValue + "\"}";
            Assert.Throws<InvalidProtocolBufferException>(() => TestAllTypes.Parser.ParseJson(json));
        }

        [Test]
        [TestCase("0", 0d)]
        [TestCase("1", 1d)]
        [TestCase("1.000000", 1d)]
        [TestCase("1.0000000000000000000000001", 1d)] // We don't notice that we haven't preserved the exact value
        [TestCase("-1", -1d)]
        [TestCase("1e1", 10d)]
        [TestCase("1e01", 10d)] // Leading decimals are allowed in exponents
        [TestCase("1E1", 10d)] // Either case is fine
        [TestCase("-1e1", -10d)]
        [TestCase("1.5e1", 15d)]
        [TestCase("-1.5e1", -15d)]
        [TestCase("15e-1", 1.5d)]
        [TestCase("-15e-1", -1.5d)]
        [TestCase("1.79769e308", 1.79769e308)]
        [TestCase("-1.79769e308", -1.79769e308)]
        [TestCase("Infinity", double.PositiveInfinity)]
        [TestCase("-Infinity", double.NegativeInfinity)]
        [TestCase("NaN", double.NaN)]
        public void StringToDouble_Valid(string jsonValue, double expectedParsedValue)
        {
            string json = "{ \"singleDouble\": \"" + jsonValue + "\"}";
            var parsed = TestAllTypes.Parser.ParseJson(json);
            Assert.AreEqual(expectedParsedValue, parsed.SingleDouble);
        }

        [Test]
        [TestCase("1.7977e308")]
        [TestCase("-1.7977e308")]
        [TestCase("1e309")]
        [TestCase("1,0")]
        [TestCase("1.0.0")]
        [TestCase("+1")]
        [TestCase("00")]
        [TestCase("01")]
        [TestCase("-00")]
        [TestCase("-01")]
        [TestCase("--1")]
        [TestCase(" Infinity")]
        [TestCase(" -Infinity")]
        [TestCase("NaN ")]
        [TestCase("Infinity ")]
        [TestCase("-Infinity ")]
        [TestCase(" NaN")]
        [TestCase("INFINITY")]
        [TestCase("nan")]
        [TestCase("\u00BD")] // 1/2 as a single Unicode character. Just sanity checking...
        public void StringToDouble_Invalid(string jsonValue)
        {
            string json = "{ \"singleDouble\": \"" + jsonValue + "\"}";
            Assert.Throws<InvalidProtocolBufferException>(() => TestAllTypes.Parser.ParseJson(json));
        }

        [Test]
        [TestCase("0", 0f)]
        [TestCase("1", 1f)]
        [TestCase("1.000000", 1f)]
        [TestCase("-1", -1f)]
        [TestCase("3.402823e38", 3.402823e38f)]
        [TestCase("-3.402823e38", -3.402823e38f)]
        [TestCase("1.5e1", 15f)]
        [TestCase("15e-1", 1.5f)]
        public void StringToFloat_Valid(string jsonValue, float expectedParsedValue)
        {
            string json = "{ \"singleFloat\": \"" + jsonValue + "\"}";
            var parsed = TestAllTypes.Parser.ParseJson(json);
            Assert.AreEqual(expectedParsedValue, parsed.SingleFloat);
        }

        [Test]
        [TestCase("3.402824e38")]
        [TestCase("-3.402824e38")]
        [TestCase("1,0")]
        [TestCase("1.0.0")]
        [TestCase("+1")]
        [TestCase("00")]
        [TestCase("--1")]
        public void StringToFloat_Invalid(string jsonValue)
        {
            string json = "{ \"singleFloat\": \"" + jsonValue + "\"}";
            Assert.Throws<InvalidProtocolBufferException>(() => TestAllTypes.Parser.ParseJson(json));
        }

        [Test]
        [TestCase("0", 0)]
        [TestCase("-0", 0)] // Not entirely clear whether we intend to allow this...
        [TestCase("1", 1)]
        [TestCase("-1", -1)]
        [TestCase("2147483647", 2147483647)]
        [TestCase("-2147483648", -2147483648)]
        [TestCase("1e1", 10)]
        [TestCase("-1e1", -10)]
        [TestCase("10.00", 10)]
        [TestCase("-10.00", -10)]
        public void NumberToInt32_Valid(string jsonValue, int expectedParsedValue)
        {
            string json = "{ \"singleInt32\": " + jsonValue + "}";
            var parsed = TestAllTypes.Parser.ParseJson(json);
            Assert.AreEqual(expectedParsedValue, parsed.SingleInt32);
        }

        [Test]
        [TestCase("+0", typeof(InvalidJsonException))]
        [TestCase("00", typeof(InvalidJsonException))]
        [TestCase("-00", typeof(InvalidJsonException))]
        [TestCase("--1", typeof(InvalidJsonException))]
        [TestCase("+1", typeof(InvalidJsonException))]
        [TestCase("1.5", typeof(InvalidProtocolBufferException))]
        // Value is out of range
        [TestCase("1e10", typeof(InvalidProtocolBufferException))]
        [TestCase("2147483648", typeof(InvalidProtocolBufferException))]
        [TestCase("-2147483649", typeof(InvalidProtocolBufferException))]
        public void NumberToInt32_Invalid(string jsonValue, System.Type expectedExceptionType)
        {
            string json = "{ \"singleInt32\": " + jsonValue + "}";
            Assert.Throws(expectedExceptionType, () => TestAllTypes.Parser.ParseJson(json));
        }

        [Test]
        [TestCase("0", 0U)]
        [TestCase("1", 1U)]
        [TestCase("4294967295", 4294967295U)]
        public void NumberToUInt32_Valid(string jsonValue, uint expectedParsedValue)
        {
            string json = "{ \"singleUint32\": " + jsonValue + "}";
            var parsed = TestAllTypes.Parser.ParseJson(json);
            Assert.AreEqual(expectedParsedValue, parsed.SingleUint32);
        }

        // Assume that anything non-bounds-related is covered in the Int32 case
        [Test]
        [TestCase("-1")]
        [TestCase("4294967296")]
        public void NumberToUInt32_Invalid(string jsonValue)
        {
            string json = "{ \"singleUint32\": " + jsonValue + "}";
            Assert.Throws<InvalidProtocolBufferException>(() => TestAllTypes.Parser.ParseJson(json));
        }

        [Test]
        [TestCase("0", 0L)]
        [TestCase("1", 1L)]
        [TestCase("-1", -1L)]
        // long.MaxValue isn't actually representable as a double. This string value is the highest
        // representable value which isn't greater than long.MaxValue.
        [TestCase("9223372036854774784", 9223372036854774784)]
        [TestCase("-9223372036854775808", -9223372036854775808)]
        public void NumberToInt64_Valid(string jsonValue, long expectedParsedValue)
        {
            string json = "{ \"singleInt64\": " + jsonValue + "}";
            var parsed = TestAllTypes.Parser.ParseJson(json);
            Assert.AreEqual(expectedParsedValue, parsed.SingleInt64);
        }

        // Assume that anything non-bounds-related is covered in the Int32 case
        [Test]
        [TestCase("9223372036854775808")]
        // Theoretical bound would be -9223372036854775809, but when that is parsed to a double
        // we end up with the exact value of long.MinValue due to lack of precision. The value here
        // is the "next double down".
        [TestCase("-9223372036854780000")]
        public void NumberToInt64_Invalid(string jsonValue)
        {
            string json = "{ \"singleInt64\": " + jsonValue + "}";
            Assert.Throws<InvalidProtocolBufferException>(() => TestAllTypes.Parser.ParseJson(json));
        }

        [Test]
        [TestCase("0", 0UL)]
        [TestCase("1", 1UL)]
        // ulong.MaxValue isn't representable as a double. This value is the largest double within
        // the range of ulong.
        [TestCase("18446744073709549568", 18446744073709549568UL)]
        public void NumberToUInt64_Valid(string jsonValue, ulong expectedParsedValue)
        {
            string json = "{ \"singleUint64\": " + jsonValue + "}";
            var parsed = TestAllTypes.Parser.ParseJson(json);
            Assert.AreEqual(expectedParsedValue, parsed.SingleUint64);
        }

        // Assume that anything non-bounds-related is covered in the Int32 case
        [Test]
        [TestCase("-1")]
        [TestCase("18446744073709551616")]
        public void NumberToUInt64_Invalid(string jsonValue)
        {
            string json = "{ \"singleUint64\": " + jsonValue + "}";
            Assert.Throws<InvalidProtocolBufferException>(() => TestAllTypes.Parser.ParseJson(json));
        }

        [Test]
        [TestCase("0", 0d)]
        [TestCase("1", 1d)]
        [TestCase("1.000000", 1d)]
        [TestCase("1.0000000000000000000000001", 1d)] // We don't notice that we haven't preserved the exact value
        [TestCase("-1", -1d)]
        [TestCase("1e1", 10d)]
        [TestCase("1e01", 10d)] // Leading decimals are allowed in exponents
        [TestCase("1E1", 10d)] // Either case is fine
        [TestCase("-1e1", -10d)]
        [TestCase("1.5e1", 15d)]
        [TestCase("-1.5e1", -15d)]
        [TestCase("15e-1", 1.5d)]
        [TestCase("-15e-1", -1.5d)]
        [TestCase("1.79769e308", 1.79769e308)]
        [TestCase("-1.79769e308", -1.79769e308)]
        public void NumberToDouble_Valid(string jsonValue, double expectedParsedValue)
        {
            string json = "{ \"singleDouble\": " + jsonValue + "}";
            var parsed = TestAllTypes.Parser.ParseJson(json);
            Assert.AreEqual(expectedParsedValue, parsed.SingleDouble);
        }

        [Test]
        // Skip these test cases in .NET 5 because floating point parsing supports bigger values.
        // These big values won't throw an error in the test.
#if !NET5_0
        [TestCase("1.7977e308")]
        [TestCase("-1.7977e308")]
        [TestCase("1e309")]
#endif
        [TestCase("1,0")]
        [TestCase("1.0.0")]
        [TestCase("+1")]
        [TestCase("00")]
        [TestCase("--1")]
        [TestCase("\u00BD")] // 1/2 as a single Unicode character. Just sanity checking...
        public void NumberToDouble_Invalid(string jsonValue)
        {
            string json = "{ \"singleDouble\": " + jsonValue + "}";
            Assert.Throws<InvalidJsonException>(() => TestAllTypes.Parser.ParseJson(json));
        }

        [Test]
        [TestCase("0", 0f)]
        [TestCase("1", 1f)]
        [TestCase("1.000000", 1f)]
        [TestCase("-1", -1f)]
        [TestCase("3.402823e38", 3.402823e38f)]
        [TestCase("-3.402823e38", -3.402823e38f)]
        [TestCase("1.5e1", 15f)]
        [TestCase("15e-1", 1.5f)]
        public void NumberToFloat_Valid(string jsonValue, float expectedParsedValue)
        {
            string json = "{ \"singleFloat\": " + jsonValue + "}";
            var parsed = TestAllTypes.Parser.ParseJson(json);
            Assert.AreEqual(expectedParsedValue, parsed.SingleFloat);
        }

        [Test]
        [TestCase("3.402824e38", typeof(InvalidProtocolBufferException))]
        [TestCase("-3.402824e38", typeof(InvalidProtocolBufferException))]
        [TestCase("1,0", typeof(InvalidJsonException))]
        [TestCase("1.0.0", typeof(InvalidJsonException))]
        [TestCase("+1", typeof(InvalidJsonException))]
        [TestCase("00", typeof(InvalidJsonException))]
        [TestCase("--1", typeof(InvalidJsonException))]
        public void NumberToFloat_Invalid(string jsonValue, System.Type expectedExceptionType)
        {
            string json = "{ \"singleFloat\": " + jsonValue + "}";
            Assert.Throws(expectedExceptionType, () => TestAllTypes.Parser.ParseJson(json));
        }

        // The simplest way of testing that the value has parsed correctly is to reformat it,
        // as we trust the formatting. In many cases that will give the same result as the input,
        // so in those cases we accept an expectedFormatted value of null. Sometimes the results
        // will be different though, due to a different number of digits being provided.
        [Test]
        // Z offset
        [TestCase("2015-10-09T14:46:23.123456789Z", null)]
        [TestCase("2015-10-09T14:46:23.123456Z", null)]
        [TestCase("2015-10-09T14:46:23.123Z", null)]
        [TestCase("2015-10-09T14:46:23Z", null)]
        [TestCase("2015-10-09T14:46:23.123456000Z", "2015-10-09T14:46:23.123456Z")]
        [TestCase("2015-10-09T14:46:23.1234560Z", "2015-10-09T14:46:23.123456Z")]
        [TestCase("2015-10-09T14:46:23.123000000Z", "2015-10-09T14:46:23.123Z")]
        [TestCase("2015-10-09T14:46:23.1230Z", "2015-10-09T14:46:23.123Z")]
        [TestCase("2015-10-09T14:46:23.00Z", "2015-10-09T14:46:23Z")]

        // +00:00 offset
        [TestCase("2015-10-09T14:46:23.123456789+00:00", "2015-10-09T14:46:23.123456789Z")]
        [TestCase("2015-10-09T14:46:23.123456+00:00", "2015-10-09T14:46:23.123456Z")]
        [TestCase("2015-10-09T14:46:23.123+00:00", "2015-10-09T14:46:23.123Z")]
        [TestCase("2015-10-09T14:46:23+00:00", "2015-10-09T14:46:23Z")]
        [TestCase("2015-10-09T14:46:23.123456000+00:00", "2015-10-09T14:46:23.123456Z")]
        [TestCase("2015-10-09T14:46:23.1234560+00:00", "2015-10-09T14:46:23.123456Z")]
        [TestCase("2015-10-09T14:46:23.123000000+00:00", "2015-10-09T14:46:23.123Z")]
        [TestCase("2015-10-09T14:46:23.1230+00:00", "2015-10-09T14:46:23.123Z")]
        [TestCase("2015-10-09T14:46:23.00+00:00", "2015-10-09T14:46:23Z")]

        // Other offsets (assume by now that the subsecond handling is okay)
        [TestCase("2015-10-09T15:46:23.123456789+01:00", "2015-10-09T14:46:23.123456789Z")]
        [TestCase("2015-10-09T13:46:23.123456789-01:00", "2015-10-09T14:46:23.123456789Z")]
        [TestCase("2015-10-09T15:16:23.123456789+00:30", "2015-10-09T14:46:23.123456789Z")]
        [TestCase("2015-10-09T14:16:23.123456789-00:30", "2015-10-09T14:46:23.123456789Z")]
        [TestCase("2015-10-09T16:31:23.123456789+01:45", "2015-10-09T14:46:23.123456789Z")]
        [TestCase("2015-10-09T13:01:23.123456789-01:45", "2015-10-09T14:46:23.123456789Z")]
        [TestCase("2015-10-10T08:46:23.123456789+18:00", "2015-10-09T14:46:23.123456789Z")]
        [TestCase("2015-10-08T20:46:23.123456789-18:00", "2015-10-09T14:46:23.123456789Z")]

        // Leap years and min/max
        [TestCase("2016-02-29T14:46:23.123456789Z", null)]
        [TestCase("2000-02-29T14:46:23.123456789Z", null)]
        [TestCase("0001-01-01T00:00:00Z", null)]
        [TestCase("9999-12-31T23:59:59.999999999Z", null)]
        public void Timestamp_Valid(string jsonValue, string expectedFormatted)
        {
            expectedFormatted = expectedFormatted ?? jsonValue;
            string json = WrapInQuotes(jsonValue);
            var parsed = Timestamp.Parser.ParseJson(json);
            Assert.AreEqual(WrapInQuotes(expectedFormatted), parsed.ToString());
        }

        [Test]
        [TestCase("2015-10-09 14:46:23.123456789Z", Description = "No T between date and time")]
        [TestCase("2015/10/09T14:46:23.123456789Z", Description = "Wrong date separators")]
        [TestCase("2015-10-09T14.46.23.123456789Z", Description = "Wrong time separators")]
        [TestCase("2015-10-09T14:46:23,123456789Z", Description = "Wrong fractional second separators (valid ISO-8601 though)")]
        [TestCase(" 2015-10-09T14:46:23.123456789Z", Description = "Whitespace at start")]
        [TestCase("2015-10-09T14:46:23.123456789Z ", Description = "Whitespace at end")]
        [TestCase("2015-10-09T14:46:23.1234567890", Description = "Too many digits")]
        [TestCase("2015-10-09T14:46:23.123456789", Description = "No offset")]
        [TestCase("2015-13-09T14:46:23.123456789Z", Description = "Invalid month")]
        [TestCase("2015-10-32T14:46:23.123456789Z", Description = "Invalid day")]
        [TestCase("2015-10-09T24:00:00.000000000Z", Description = "Invalid hour (valid ISO-8601 though)")]
        [TestCase("2015-10-09T14:60:23.123456789Z", Description = "Invalid minutes")]
        [TestCase("2015-10-09T14:46:60.123456789Z", Description = "Invalid seconds")]
        [TestCase("2015-10-09T14:46:23.123456789+18:01", Description = "Offset too large (positive)")]
        [TestCase("2015-10-09T14:46:23.123456789-18:01", Description = "Offset too large (negative)")]
        [TestCase("2015-10-09T14:46:23.123456789-00:00", Description = "Local offset (-00:00) makes no sense here")]
        [TestCase("0001-01-01T00:00:00+00:01", Description = "Value before earliest when offset applied")]
        [TestCase("9999-12-31T23:59:59.999999999-00:01", Description = "Value after latest when offset applied")]
        [TestCase("2100-02-29T14:46:23.123456789Z", Description = "Feb 29th on a non-leap-year")]
        public void Timestamp_Invalid(string jsonValue)
        {
            string json = WrapInQuotes(jsonValue);
            Assert.Throws<InvalidProtocolBufferException>(() => Timestamp.Parser.ParseJson(json));
        }

        [Test]
        public void StructValue_Null()
        {
            Assert.AreEqual(new Value { NullValue = 0 }, Value.Parser.ParseJson("null"));
        }

        [Test]
        public void StructValue_String()
        {
            Assert.AreEqual(new Value { StringValue = "hi" }, Value.Parser.ParseJson("\"hi\""));
        }

        [Test]
        public void StructValue_Bool()
        {
            Assert.AreEqual(new Value { BoolValue = true }, Value.Parser.ParseJson("true"));
            Assert.AreEqual(new Value { BoolValue = false }, Value.Parser.ParseJson("false"));
        }

        [Test]
        public void StructValue_List()
        {
            Assert.AreEqual(Value.ForList(Value.ForNumber(1), Value.ForString("x")), Value.Parser.ParseJson("[1, \"x\"]"));
        }

        [Test]
        public void Value_List_WithNullElement()
        {
            var expected = Value.ForList(Value.ForString("x"), Value.ForNull(), Value.ForString("y"));
            var actual = Value.Parser.ParseJson("[\"x\", null, \"y\"]");
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void StructValue_NullElement()
        {
            var expected = Value.ForStruct(new Struct { Fields = { { "x", Value.ForNull() } } });
            var actual = Value.Parser.ParseJson("{ \"x\": null }");
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void ParseListValue()
        {
            Assert.AreEqual(new ListValue { Values = { Value.ForNumber(1), Value.ForString("x") } }, ListValue.Parser.ParseJson("[1, \"x\"]"));
        }

        [Test]
        public void StructValue_Struct()
        {
            Assert.AreEqual(
                Value.ForStruct(new Struct { Fields = { { "x", Value.ForNumber(1) }, { "y", Value.ForString("z") } } }),
                Value.Parser.ParseJson("{ \"x\": 1, \"y\": \"z\" }"));
        }

        [Test]
        public void ParseStruct()
        {
            Assert.AreEqual(new Struct { Fields = { { "x", Value.ForNumber(1) }, { "y", Value.ForString("z") } } },
                Struct.Parser.ParseJson("{ \"x\": 1, \"y\": \"z\" }"));
        }

        // TODO for duration parsing: upper and lower bounds.
        // +/- 315576000000 seconds

        [Test]
        [TestCase("1.123456789s", null)]
        [TestCase("1.123456s", null)]
        [TestCase("1.123s", null)]
        [TestCase("1.12300s", "1.123s")]
        [TestCase("1.12345s", "1.123450s")]
        [TestCase("1s", null)]
        [TestCase("-1.123456789s", null)]
        [TestCase("-1.123456s", null)]
        [TestCase("-1.123s", null)]
        [TestCase("-1s", null)]
        [TestCase("0.123s", null)]
        [TestCase("-0.123s", null)]
        [TestCase("123456.123s", null)]
        [TestCase("-123456.123s", null)]
        // Upper and lower bounds
        [TestCase("315576000000s", null)]
        [TestCase("-315576000000s", null)]
        public void Duration_Valid(string jsonValue, string expectedFormatted)
        {
            expectedFormatted = expectedFormatted ?? jsonValue;
            string json = WrapInQuotes(jsonValue);
            var parsed = Duration.Parser.ParseJson(json);
            Assert.AreEqual(WrapInQuotes(expectedFormatted), parsed.ToString());
        }

        // The simplest way of testing that the value has parsed correctly is to reformat it,
        // as we trust the formatting. In many cases that will give the same result as the input,
        // so in those cases we accept an expectedFormatted value of null. Sometimes the results
        // will be different though, due to a different number of digits being provided.
        [Test]
        [TestCase("1.1234567890s", Description = "Too many digits")]
        [TestCase("1.123456789", Description = "No suffix")]
        [TestCase("1.123456789ss", Description = "Too much suffix")]
        [TestCase("1.123456789S", Description = "Upper case suffix")]
        [TestCase("+1.123456789s", Description = "Leading +")]
        [TestCase(".123456789s", Description = "No integer before the fraction")]
        [TestCase("1,123456789s", Description = "Comma as decimal separator")]
        [TestCase("1x1.123456789s", Description = "Non-digit in integer part")]
        [TestCase("1.1x3456789s", Description = "Non-digit in fractional part")]
        [TestCase(" 1.123456789s", Description = "Whitespace before fraction")]
        [TestCase("1.123456789s ", Description = "Whitespace after value")]
        [TestCase("01.123456789s", Description = "Leading zero (positive)")]
        [TestCase("-01.123456789s", Description = "Leading zero (negative)")]
        [TestCase("--0.123456789s", Description = "Double minus sign")]
        // Violate upper/lower bounds in various ways
        [TestCase("315576000001s", Description = "Integer part too large")]
        [TestCase("3155760000000s", Description = "Integer part too long (positive)")]
        [TestCase("-3155760000000s", Description = "Integer part too long (negative)")]
        public void Duration_Invalid(string jsonValue)
        {
            string json = WrapInQuotes(jsonValue);
            Assert.Throws<InvalidProtocolBufferException>(() => Duration.Parser.ParseJson(json));
        }

        // Not as many tests for field masks as I'd like; more to be added when we have more
        // detailed specifications.

        [Test]
        [TestCase("")]
        [TestCase("foo", "foo")]
        [TestCase("foo,bar", "foo", "bar")]
        [TestCase("foo.bar", "foo.bar")]
        [TestCase("fooBar", "foo_bar")]
        [TestCase("fooBar.bazQux", "foo_bar.baz_qux")]
        public void FieldMask_Valid(string jsonValue, params string[] expectedPaths)
        {
            string json = WrapInQuotes(jsonValue);
            var parsed = FieldMask.Parser.ParseJson(json);
            CollectionAssert.AreEqual(expectedPaths, parsed.Paths);
        }

        [Test]
        [TestCase("foo_bar")]
        public void FieldMask_Invalid(string jsonValue)
        {
            string json = WrapInQuotes(jsonValue);
            Assert.Throws<InvalidProtocolBufferException>(() => FieldMask.Parser.ParseJson(json));
        }

        [Test]
        public void Any_RegularMessage()
        {
            var registry = TypeRegistry.FromMessages(TestAllTypes.Descriptor);
            var formatter = new JsonFormatter(new JsonFormatter.Settings(false, TypeRegistry.FromMessages(TestAllTypes.Descriptor)));
            var message = new TestAllTypes { SingleInt32 = 10, SingleNestedMessage = new TestAllTypes.Types.NestedMessage { Bb = 20 } };
            var original = Any.Pack(message);
            var json = formatter.Format(original); // This is tested in JsonFormatterTest
            var parser = new JsonParser(new JsonParser.Settings(10, registry));
            Assert.AreEqual(original, parser.Parse<Any>(json));
            string valueFirstJson = "{ \"singleInt32\": 10, \"singleNestedMessage\": { \"bb\": 20 }, \"@type\": \"type.googleapis.com/protobuf_unittest3.TestAllTypes\" }";
            Assert.AreEqual(original, parser.Parse<Any>(valueFirstJson));
        }

        [Test]
        public void Any_CustomPrefix()
        {
            var registry = TypeRegistry.FromMessages(TestAllTypes.Descriptor);
            var message = new TestAllTypes { SingleInt32 = 10 };
            var original = Any.Pack(message, "custom.prefix/middle-part");
            var parser = new JsonParser(new JsonParser.Settings(10, registry));
            string json = "{ \"@type\": \"custom.prefix/middle-part/protobuf_unittest3.TestAllTypes\", \"singleInt32\": 10 }";
            Assert.AreEqual(original, parser.Parse<Any>(json));
        }

        [Test]
        public void Any_UnknownType()
        {
            string json = "{ \"@type\": \"type.googleapis.com/bogus\" }";
            Assert.Throws<InvalidOperationException>(() => Any.Parser.ParseJson(json));
        }

        [Test]
        public void Any_NoTypeUrl()
        {
            string json = "{ \"foo\": \"bar\" }";
            Assert.Throws<InvalidProtocolBufferException>(() => Any.Parser.ParseJson(json));
        }

        [Test]
        public void Any_WellKnownType()
        {
            var registry = TypeRegistry.FromMessages(Timestamp.Descriptor);
            var formatter = new JsonFormatter(new JsonFormatter.Settings(false, registry));
            var timestamp = new DateTime(1673, 6, 19, 12, 34, 56, DateTimeKind.Utc).ToTimestamp();
            var original = Any.Pack(timestamp);
            var json = formatter.Format(original); // This is tested in JsonFormatterTest
            var parser = new JsonParser(new JsonParser.Settings(10, registry));
            Assert.AreEqual(original, parser.Parse<Any>(json));
            string valueFirstJson = "{ \"value\": \"1673-06-19T12:34:56Z\", \"@type\": \"type.googleapis.com/google.protobuf.Timestamp\" }";
            Assert.AreEqual(original, parser.Parse<Any>(valueFirstJson));
        }

        [Test]
        public void Any_Nested()
        {
            var registry = TypeRegistry.FromMessages(TestWellKnownTypes.Descriptor, TestAllTypes.Descriptor);
            var formatter = new JsonFormatter(new JsonFormatter.Settings(false, registry));
            var parser = new JsonParser(new JsonParser.Settings(10, registry));
            var doubleNestedMessage = new TestAllTypes { SingleInt32 = 20 };
            var nestedMessage = Any.Pack(doubleNestedMessage);
            var message = new TestWellKnownTypes { AnyField = Any.Pack(nestedMessage) };
            var json = formatter.Format(message);
            // Use the descriptor-based parser just for a change.
            Assert.AreEqual(message, parser.Parse(json, TestWellKnownTypes.Descriptor));
        }

        [Test]
        public void DataAfterObject()
        {
            string json = "{} 10";
            Assert.Throws<InvalidJsonException>(() => TestAllTypes.Parser.ParseJson(json));
        }

        /// <summary>
        /// JSON equivalent to <see cref="CodedInputStreamTest.MaliciousRecursion"/>
        /// </summary>
        [Test]
        public void MaliciousRecursion()
        {
            string data64 = CodedInputStreamTest.MakeRecursiveMessage(64).ToString();
            string data65 = CodedInputStreamTest.MakeRecursiveMessage(65).ToString();

            var parser64 = new JsonParser(new JsonParser.Settings(64));
            CodedInputStreamTest.AssertMessageDepth(parser64.Parse<TestRecursiveMessage>(data64), 64);
            Assert.Throws<InvalidProtocolBufferException>(() => parser64.Parse<TestRecursiveMessage>(data65));

            var parser63 = new JsonParser(new JsonParser.Settings(63));
            Assert.Throws<InvalidProtocolBufferException>(() => parser63.Parse<TestRecursiveMessage>(data64));
        }

        [Test]
        [TestCase("AQI")]
        [TestCase("_-==")]
        public void Bytes_InvalidBase64(string badBase64)
        {
            string json = "{ \"singleBytes\": \"" + badBase64 + "\" }";
            Assert.Throws<InvalidProtocolBufferException>(() => TestAllTypes.Parser.ParseJson(json));
        }

        [Test]
        [TestCase("\"FOREIGN_BAR\"", ForeignEnum.ForeignBar)]
        [TestCase("5", ForeignEnum.ForeignBar)]
        [TestCase("100", (ForeignEnum)100)]
        public void EnumValid(string value, ForeignEnum expectedValue)
        {
            string json = "{ \"singleForeignEnum\": " + value + " }";
            var parsed = TestAllTypes.Parser.ParseJson(json);
            Assert.AreEqual(new TestAllTypes { SingleForeignEnum = expectedValue }, parsed);
        }

        [Test]
        [TestCase("\"NOT_A_VALID_VALUE\"")]
        [TestCase("5.5")]
        public void Enum_Invalid(string value)
        {
            string json = "{ \"singleForeignEnum\": " + value + " }";
            Assert.Throws<InvalidProtocolBufferException>(() => TestAllTypes.Parser.ParseJson(json));
        }

        [Test]
        public void OneofDuplicate_Invalid()
        {
            string json = "{ \"oneofString\": \"x\", \"oneofUint32\": 10 }";
            Assert.Throws<InvalidProtocolBufferException>(() => TestAllTypes.Parser.ParseJson(json));
        }

        [Test]
        public void UnknownField_NotIgnored()
        {
            string json = "{ \"unknownField\": 10, \"singleString\": \"x\" }";
            Assert.Throws<InvalidProtocolBufferException>(() => TestAllTypes.Parser.ParseJson(json));
        }

        [Test]
        public void Proto2_DefaultValuesPreserved()
        {
            string json = "{ \"FieldName13\": 0 }";
            var parsed = TestAllTypesProto2.Parser.ParseJson(json);
            Assert.False(parsed.HasFieldName10);
            Assert.True(parsed.HasFieldName13);
            Assert.AreEqual(0, parsed.FieldName13);
        }

        [Test]
        [TestCase("5")]
        [TestCase("\"text\"")]
        [TestCase("[0, 1, 2]")]
        [TestCase("{ \"a\": { \"b\": 10 } }")]
        public void UnknownField_Ignored(string value)
        {
            var parser = new JsonParser(JsonParser.Settings.Default.WithIgnoreUnknownFields(true));
            string json = "{ \"unknownField\": " + value + ", \"singleString\": \"x\" }";
            var actual = parser.Parse<TestAllTypes>(json);
            var expected = new TestAllTypes { SingleString = "x" };
            Assert.AreEqual(expected, actual);
        }

        [Test]
        public void NullValueOutsideStruct_NullLiteral()
        {
            string json = "{ \"nullValue\": null }";
            var message = NullValueOutsideStruct.Parser.ParseJson(json);
            Assert.AreEqual(NullValueOutsideStruct.ValueOneofCase.NullValue, message.ValueCase);
        }

        [Test]
        public void NullValueNotInOneof_NullLiteral()
        {
            // We'd only normally see this with FormatDefaultValues set to true.
            string json = "{ \"nullValue\": null }";
            var message = NullValueNotInOneof.Parser.ParseJson(json);
            Assert.AreEqual(NullValue.NullValue, message.NullValue);
        }

        // NullValue used to only be converted to the null literal when part of a struct.
        // Otherwise, it would end up as a string "NULL_VALUE" (the name of the enum value).
        // We still parse that form, for compatibility.
        [Test]
        public void NullValueOutsideStruct_Compatibility()
        {
            string json = "{ \"nullValue\": \"NULL_VALUE\" }";
            var message = NullValueOutsideStruct.Parser.ParseJson(json);
            Assert.AreEqual(NullValueOutsideStruct.ValueOneofCase.NullValue, message.ValueCase);
        }

        [Test]
        public void NullValueNotInOneof_Compatibility()
        {
            // We'd only normally see this with FormatDefaultValues set to true.
            string json = "{ \"nullValue\": \"NULL_VALUE\" }";
            var message = NullValueNotInOneof.Parser.ParseJson(json);
            Assert.AreEqual(NullValue.NullValue, message.NullValue);
        }

        /// <summary>
        /// Various tests use strings which have quotes round them for parsing or as the result
        /// of formatting, but without those quotes being specified in the tests (for the sake of readability).
        /// This method simply returns the input, wrapped in double quotes.
        /// </summary>
        internal static string WrapInQuotes(string text)
        {
            return '"' + text + '"';
        }
    }
}

redpajama_set_name: RedPajamaGithub


text:
package com.alibaba.dubbo.user.provider.service;

import javax.annotation.Resource;

import org.apache.commons.configuration.XMLConfiguration;
import org.apache.commons.lang3.RandomStringUtils;
import org.springframework.beans.factory.annotation.Autowired;

import com.alibaba.dubbo.rpc.RpcContext;
import com.alibaba.dubbo.user.api.domain.User;
import com.alibaba.dubbo.user.api.service.UserService;
import com.alibaba.dubbo.user.provider.dao.db1.Task1Dao;
import com.alibaba.dubbo.user.provider.dao.db2.Task2Dao;
import com.alibaba.dubbo.user.provider.dao.jdbc.TaskJdbcDao;
import com.alibaba.dubbo.user.provider.model.Task1;
import com.alibaba.dubbo.user.provider.model.Task2;

/**
 *
 * @author Shunli
 */
public class UserServiceImpl implements UserService {

    @Resource(name = "userConfig")
    private XMLConfiguration config;

    @Autowired
    private Task1Dao task1Dao;

    @Autowired
    private Task2Dao task2Dao;

    @Autowired
    private TaskJdbcDao taskJdbcDao;

    @Override
    public User getUser(String id) {
        System.out.println(RpcContext.getContext().getLocalAddressString() + " UserService.getUser() invoked");

        System.out.println(config.getString("db.name"));

        task1Dao.save(new Task1("t1_" + random(), "d1_" + random(), "eT_" + random()));
        task2Dao.save(new Task2("t2_" + random(), "d2_" + random()));

        System.out.println(task1Dao.findByTitleStartingWith("t1_C"));
        System.out.println(task1Dao.findOne(1L));
        System.out.println(task1Dao.findAll());

        taskJdbcDao.test();

        User user = new User(id, "name" + id);
        return user;
    }

    private String random() {
        return RandomStringUtils.randomAlphanumeric(6);
    }
}


text:
module RedmineUpdateReminder
  module Patches
    module UserPatch
      def self.included(base)

        base.class_eval do
          unloadable
          has_many :members, inverse_of: :user
        end
      end

    end
  end
end


text:
Notre Dame Athletics Director Jack Swarbrick wasn't surprised Brian Kelly wanted out
Mike Hutton - @MikeHuttonPT
Notre Dame Athletics Director Jack Swarbrick had a sense that former Notre Dame football coach Brian Kelly might be restless.
His intuition was correct.
Kelly was announced as the coach at LSU on Tuesday. His contract is reportedly for $95 million over 10 years.
Before he took the LSU job, there was speculation that Kelly had conversations with USC about its open job. The Trojans hired Oklahoma coach Lincoln Riley last week.
"It was sometime last night," Swarbrick said about when he found out Kelly was gone. "I can't give you the exact time. I was not surprised. There had been enough in the weeks leading up that gave me a pretty strong sense that there might be other things attracting Brian. And of course, social media was very active yesterday. Between those two things, I was not surprised."
Kelly met with the Fighting Irish players Tuesday morning at 7 AM EST to inform them he was making the move after 12 seasons at Notre Dame. The news broke in the middle of the day on Monday on social media.
Kelly leaves an 11-1 team that has a chance to earn a bid to the College Football Playoff. The Fighting Irish will know next week if they are one of the four teams selected. Kelly leaves as the winningest coach in Notre Dame history. His record was 113-40. The Fighting Irish won 10 games seven times and he was the Home Depot College Football Coach of the Year in 2012 and 2018 at Notre Dame and in 2009 at Cincinnati.
According to Swarbrick, Kelly did not discuss the conversations he was having with LSU about taking the job. There was no opportunity for Swarbrick to make a counter or convince Kelly to stay.
"I have to let Brian answer the question of why he left Notre Dame," Swarbrick said. "I can't answer that. There is a sense you get when you work with someone closely for 12 years that there is a certain restlessness. I could sense that in some conversations. There was a Freudian slip or two along the way that grabbed my attention. And whether that was intentional or not, it just felt like someone who might be open to a different opportunity."
Swarbrick emphasized that leaving for Kelly wasn't about resources.
"It wasn't a conversation about gosh, I need X or Y to remain at Notre Dame," Swarbrick said. "I would not have resisted those conversations. Let me stress, we are always talking about improvements in the program. We have capital improvements that span the next three years. It's not about not doing things to get better. It's just we talked about what those things would be and what they would look like and there wasn't any distance between us."
Swarbrick said that Kelly told the team in the morning meeting that it was about a new challenge.
"He said it was about another opportunity and a new experience for his family," Swarbrick explained. "It was similar to the comments that Lincoln (Riley) made the day before when he left. I think there is an element to that. There was no sense I think that it was motivated by a belief that we couldn't take the next step here. Brian has consistently reinforced to the team that we are positioned to take that next step and I passionately believe that."
Notre Dame Hopes Its OL Tradition Can Impress Elite OL Samson Okunlola
It's Official: Notre Dame Hires Brian Mason As Special Teams Coordinator
Safety KJ Wallace To Enter The Transfer Portal
Swarbrick said that he doesn't intend to hire an interim coach at this time. The job will be shared.
"We haven't made a decision on an interim yet and frankly, I think we may approach it a little bit differently," he said. "This staff is so well structured and the responsibilities so understood, I feel less of a need to have a designated interim. If we feel the need to put somebody in that position, they would not be a candidate for the job."
Be sure to check out the Irish Breakdown message board, the Champions Lounge
Irish Breakdown Content
Notre Dame 2021 Roster
Notre Dame 2021 Schedule
Notre Dame 2022 Commits Big Board: Offense
Notre Dame 2022 Commits Big Board: Defense
Notre Dame 2022 Scholarship Offers
Notre Dame 2022 Class Big Board
Become a premium Irish Breakdown member, which grants you access to all of our premium content and our premium message board! Click on the link below for more.
Be sure to stay locked into Irish Breakdown all the time!
Join the Irish Breakdown community!
Subscribe to the Irish Breakdown YouTube channel
Subscribe to the Irish Breakdown podcast on iTunes
Follow me on Twitter: @MikeHuttonPT
Like and follow Irish Breakdown on Facebook
Sign up for the FREE Irish Breakdown daily newsletter
By Ryan Roberts
By Bryan Driskell
Notre Dame Offers Elite 2024 Running Back Stacy Gage
Kyle Hamilton To The Big Apple In Mock Draft From Mel Kiper Jr.
Elite 2024 Quarterback Julian Sayin Sees Notre Dame As A Great Fit
Irish Breakdown Show: Notre Dame Receivers Have Talent, But Major Questions Persist
Midweek Musings: Receiver Help Is Already On Campus, Notre Dame DL Breakout Player

redpajama_set_name: RedPajamaCommonCrawl


Radiology is a major part of diagnosing patients who have certain conditions by the use of x-rays, CT scans, MRI scans, PET scans, fusion imaging, and ultrasounds. With the amount of radiation used in these medical imaging techniques and the complexity of the machines, those wanting to enter the field of radiology need continuing medical education. Completing these courses will offer a wide variety of advantages, such as enhanced career opportunities, but it can be difficult when you've already entered your career field. Here are three benefits of taking radiology CME online courses.
Radiology is an important part of the medical field as it allows medical professionals to see inside the body to make a diagnosis that would otherwise be difficult and dangerous. However, working in radiology takes a specific type of training as patients are exposed to a low amount of radiation. For this reason, it's important to understand when a patient is in need of a medical imaging scan and what type of scan is needed as you don't want to expose the patient to any unnecessary radiation. Taking radiology CME courses will provide this knowledge, preparing you for working in the world of radiology.
Becoming a radiologic technician offers many advantages, such as a potentially higher salary, but that's not all. Entering this field will create additional career opportunities as you can specialize in a specific type of radiology, becoming an MRI technologist, computed tomography (CT), radiation therapy, nuclear medicine, and mammography, among others. By continuing your medical education into radiology you'll be able to expand your career opportunities through additional certifications. This education will also demand a higher salary as many of these positions are paid on certification level.
One of the major drawbacks of going back to school is that you already work long hours and may not have the time to attend classes. Thousands of medical professionals advance their career by furthering their education with online courses. You'll be able to work on the course in your time, allowing you to continue your daily activities while advancing your career. These online courses are designed for those that have already entered a field and are looking to further their education so if you're already working long hours, they've been designed for you.
Radiology is an important part of the medical field and needs specialized technicians for the operation of the equipment. Radiology CME online courses will allow you to expand your career into radiology, allowing for more career opportunities and a higher salary, all in your time.


text:
Tag: European Space Agency
Entertainment, News, Space and Science, Virtual Reality (VR), VR World
BBC striving to bring VR to the mainstream via new studio
December 3, 2017 Reece Sellin
The British Broadcasting Corporation (BBC) has announced ambitious plans to expand the scope of their VR content production. The broadcaster says that it has now formed a studio dedicated to virtual reality, enabling it to build upon its previous VR content. The BBC's previous VR efforts have included We Wait, addressing the global refugee crisis; The Turning Forest, a fairy tale based in a magical forest; and Trafficked, a 360-degree documentary regarding human trafficking in Mexico. Concomitant with this week's announcement was the wide release of A VR Spacewalk, an experience based on NASA and European Space agency training programs. While A VR Spacewalk had


As we age, our oral health becomes more important than ever. Periodontal disease can lead to bone and tooth loss, which affects nearly every part of our daily lives. To lead full and active lives, we need our teeth and gums. They allow us enjoy food, support speech and good conversation, and facilitate digestion. Drs. Quang Le or Vinh Le is dedicated to treating elderly patients with care and commitment to comfort and health.
For elderly patients embarrassed or fearful of their current oral state, sedation dentistry provides the opportunity for Drs. Quang Le or Vinh Le to treat these conditions while the patient remains relaxed and unaware until "awaking" to an improved oral state!
It may be especially difficult for people with disabilities to obtain access to proper dental care. They must find a dentist who is skilled and compassionate, and who can provide services for which some dentists may not be qualified. At Santa Fe Dental Group, we provide the expertise, state-of-the-art-equipment, and dedication to assisting special-needs patients necessary to ensuring great oral care for our patients.
Disabled patients may face added challenges in maintaining their oral health. Their disability may make it difficult to brush or floss regularly; they may also suffer a severe gag reflex, or dry mouth as a result of medication. Drs. Quang Le or Vinh Le meets these challenges with sedation dentistry for the disabled. Drs. Quang Le or Vinh Le is skilled in anesthesia for special-needs patients, and can ease the fear associated with out-of-control oral hygiene with one visit.
If you suffer from dental phobia- fear no more! At Santa Fe Dental Group, we are committed to understanding the very real nature of your fears. Not only will our staff treat you with delicacy and care, but IV sedation will allow you to experience dentistry in a whole new way. While engaging in a pleasant sleep-like experience, Drs. Quang Le or Vinh Le will be hard at work making sure you "wake up" with the results you desire.


text:
Q: Is there a way to have the iPhone suggest corrections but not automatically apply them? The iPhone's autocorrect function is wrong for me more often than not, but I'd still like to see its suggestions and have a way to apply them - they just shouldn't be applied automatically. Is there a way to do this?

A: In a nutshell: No (but it would be nice to have)

redpajama_set_name: RedPajamaStackExchange


Where: Natural trees are recyclable as regular brush, and may be placed on the curb as brush collection.Matter of fact I nearly got that laptop for going back to the spring semester at. just apparently not bitcoin mining. EX:.Bitcoin is the first decentralized peer-to-peer payment network that is powered by its users with no central authority or middlemen.
This article looking at Bitcoins and the performance of various GPUs with mining them was really a big team effort at PC Perspective.
Leaving your laptop up and running continuously for 1 month will cost you much.
You can begin mining in minutes after signing up for free and downloading. Bitcoin Mining Hardware. computer or laptop will just not cut it in the mining.Bitcoin Mining Hardware Guide The best Bitcoin mining hardware has evolved dramatically since 2009.Mining Proof of Work Mining Difficulty What is Bitcoin Cloud Mining.
In this section, you can get the inside scoop on heating and bitcoin.Our software is the easiest way to mine Bitcoin, or any other cryptocurrency we support.
Find all you need to know and get started with Bitcoin on bitcoin.org.Bitcoin Mining Software Laptop - Should I Mine Bitcoins Bitcoin Mining Software Laptop Bitcoin Worksheet Bitcoin Ticker Philippines.


text:
Loyal fireman will be missed
Published: 9:20 AM March 1, 2012
The fire service are wishing one of their key members luck in his retirement.
A FAITHFUL fireman with a 30-year career behind him is finally saying goodbye to the fire service.
Rhys Evans, pictured left, Group Manager of Devon and Somerset Fire and Rescue Service, is looking forward to dedicating more time to making music with his local folk group, The Oggle Band.
Rhys, who grew up in North Devon and lives in Barnstaple, first joined the fire brigade because he felt motivated to do something for the community.
He said: "Without exception, people who work in and alongside the emergency services all have the interests of the community at heart, and it's good to have seen such an increase in collaborative working over the past few years."
"I have met and worked alongside some wonderful people and I am still constantly amazed by the dedication of the retained fire-fighters, who hold down other jobs, but are prepared to drop everything to turn out for an emergency."
Bideford's serving fire fighters said they and the whole region would miss Rhy's relaxed manner, both on the incident ground and around the stations, and wished him the best of luck.


text:
FutureStories Archives
Stacy: TechBots
Dealing with mental preadolescents every day is enough to make you want to overwrite your primary drive. Or, you know, theirs.
The whinging tones come through loud and clear, even via electronic format. The complete lack of reading comprehension is astonishing in (apparent) adults, causing the chewing of fingernails, obsessive consumption of caffeine, and other nervous habits endemic to my kind.
They want help and yet they are ill-equipped to deal with it, having a lack of both mental acumen and the will to help themselves. Needless to say, this does not endear them to us, despite our basic programming.
Read more from Stacy's FutureStories.
Permalink Bookmark: del.icio.us • Digg • reddit
Stacy: Human Nature
Moon Base Alpha's construction was proceeding nicely. After a disastrous first year, with near 50% casualties, the training had finally caught up with the reality, and now only actual veterans taught the noobs what they needed to know to avoid spacing themselves. It also made for good PR back home, especially when the bleeding hearts in the World Congress screeched about the "cost in human lives".
'Still, the occasional accident will happen,' thought Lancaster, as he pulled the body towards the airlock, again thankful for the 1/8 gravity. The airlock cycled open then closed, and Lancaster returned to duty, whistling.
Read more from Stacy's FutureStories.It Came From Outer Space.
Stacy: Uh Oh
James finished packing his gear and looked warily around the clearing. The cycads and ferns were unmoving in the hot afternoon silence. Even with the perimeter monitors and notated schedules, he still worried about the possibility of a close encounter.
He shouldered his pack and walked toward the port terminal. He had plenty of time before the local predators awoke from their daily siesta, his watch still read one-thirty, earth standard time. Wait...STILL read...
The foliage on the north side of the clearing shuddered, and a russet head poked through, bony head ridges prominent.
Allosaurus atrox, he thought.
Stacy: Sabotage
There was a dull crump from the laboratory. Doors burst open, scientists pelting madly in all directions.
'Nowhere to run,' thought Brighton. He dropped the cutting laser into a wastebin and sauntered through the compound, not caring who noticed. In seventy seconds it would hardly matter who thought what at the Rockwell Fusion Research Labratory.
He found a niche, settled in to watch as the lab building folded in on itself. Decades of research felled by a tiny flaw.
In the millisecond before he died, Brighton noted the green hue of the plasma bubble.
'The color of money,' he thought.
Read more from Stacy's FutureStories.R&D.
Stacy: History
James read the memorial plaque again, even though he could recite it by heart:
Manhattan Island, once a bastion of commerce, cuisine and fashion, now lies beneath 100 meters of sea water, a tribute to man's folly.
"Stupid memorial," he thought. "Doesn't even tell the real reason why it happened."
He came out here every night, had since it happened, three years ago. As a mechanical engineer, he knew the reason for the island's submergence, that held no mystery for him.
What really drew him here, night after night, was the single light still shining from the top floor window.
Stacy: Doin' Time
We walk around the yard aimlessly, nowhere to go, no place to be. The guards flick their stinger whips at stragglers, keep the herd moving.
Talking is allowed, but most of us have nothing to say. Had it whipped out of us over the years. Newbie up front is a chatterbox. That'll change soon enough.
"You know, I've played the violin all my life," I overheard him say. "I think the thing I miss most, even more than food, is my music."
I laugh to myself. Old man hasn't even been here for a week. He don't know hungry yet.
Stacy: Shopping
"I'm the Holmes ZX4000," she said haughtily. "I'm the single most expensive construct available on the market today. I'm highly intelligent, flexible, and extensible. I am not the everyday sort of construct, and will not do well at menial chores. I am for special occasions, social events, and important dinners."
She paused for breath and I checked her price tag. Eleven million, eh? And I bet she didn't even give head.
She started to speak again, then paused, staring at her hands. "Sale?" she whispered, outraged. "I'm ON SALE?!?"
I checked the tag again. 3.2 million, eh? I'll take two.
Stacy: Fortress
"This is not a drill, if you haven't already, take......"
The radio buzzed into silence, along with everything else as the grid went down. There was a distant chuff as generator power kicked in, bringing up emergency lights and environmentals. Faint slamming sounds came to us in the unnatural stillness as the metal shutters slid shut, and then an even fainter buzzing as the perimeter fence came online.
Thad came into the control center as I completed the sensor sweep. I ruffled his nine year old head and smiled reassuringly at him. "No school today, eh, mom?" he piped cheerfully.
Stacy: The Researcher
Even with Jupiter's great bulk out of the way, FTL radio had been hissing static for a week now. When he finally got up enough interest to turn the 15 meter scope towards Earth, he was unsurprised to find the planet shrouded in white, no hint of it's typical blue-green visible. The stations at the LaGrange points were completely dark, no shuttle traffic between them and Luna. Mount Olympus' relay beacon was likewise silent.
Shrugging to himself, he turned the FTL radio receiver off, pointed the scope back out past the Kuiper belt, and continued his study of Asteroid 134340.
Stacy: Hysterical History
He walked down the long drive to their mailbox, whistling. He couldn't recall when he'd been so happy. His career was hot, and his agent was talking Oscar for his last role. Angie was happy, with her collection of kids. Hell, he loved them, too, even the ones that weren't his. Yes, life was good.
He opened the mailbox, retrieved the usual junk. A black envelope caught his eye, it's silver lettering proclaiming it was from Future Fixers, Inc. A sheet of paper inside read:
Save the future… kill your wife.
He shrugged and went off to find the shotgun.
Read more from Stacy's Future Fixers Inc.
Continue reading FutureStories's Archives:
« 1 · 2 »


text:
IPP3 Tri-Fuel Power Plant
Jordan's IPP3, located on a green field site at Al Manakher, 30km from the Jordanian capital Amman, is the world's biggest tri-fuel power plant, with an installed capacity of 573MW.
Amman Asia Electric Power Company (AAEPC)
Inaugurated
$812m
Wärtsilä 50DF internal combustion engines (ICE)
EPC Contractor
Consortium of Wärtsilä and Lotte Engineering & Construction
Jordan's IPP3 is the world's biggest tri-fuel power plant, with an installed capacity of 573MW. Image: courtesy of Wärtsilä.
The power plant uses natural gas and heavy fuel oil (HFO) as its main fuels and light fuel oil (LFO) as the back-up fuel. Image: courtesy of Wärtsilä.
IPP3 is equipped with 38 Wärtsilä 50DF internal combustion engines (ICE). Image: courtesy of Wärtsilä.
Jordan's IPP3, located on a green field site at Al Manakher, 30km from the Jordanian capital Amman, is the world's biggest tri-fuel power plant, with an installed capacity of 573MW. The plant is designed to use natural gas and heavy fuel oil (HFO) as its main fuels and light fuel oil (HFO) as the back-up fuel.
The project broke ground in April 2013, the commissioning works were performed between January 2014 and October 2014, and the plant was officially inaugurated in March 2015.
The client for the project is National Electric Power Company (NEPCO). Amman Asia Electric Power Company (AAEPC), a consortium of Korea Electric Power Corporation (KEPCO, 60%), Mitsubishi Corporation (MC, 35%) and Wärtsilä Development & Financial Services (WDFS, 5%) are to build, own and operate the power plant.
The project will enable the country to meet its target of achieving energy self-sufficiency by 2020 and reduce the dependency on Egyptian gas. The country further aims to install 600MW of solar and 1,200MW of wind energy by 2020.
IPP3 power plant make-up
Tzafit Gas Fired Power Plant, Israel
Tzafit power station is an 835MW combined-cycle, natural gas-fired plant under construction in Israel.
The power plant is equipped with 38 Wärtsilä 50DF internal combustion engines (ICE), which can produce 573MW of electricity at the country's harsh ambient conditions and 632MW at conditions set by the International Organisation for Standardisation (ISO).
The plant is capable of switching fuels during operation, without causing a fall in the generation capacity. It will be fuelled by HFO and LFO through 2015, and start using natural gas when gas supply facilities are in place.
The first 16 engines came online in January 2014 and the remaining were commissioned subsequently. The project also involved the construction of the Amman East 400kV substation at the site, which integrates 12 x 400kV transformer bays.
Jordan's IPP3 sustainability features
The plant operates with virtually no usage of water and generates approximately 35% less CO² emissions per kilowatt hour (kWh) compared to an oil-fired steam power plant. The plant is also equipped with control systems and facilities to check nitrogen oxide (NOx), sulphur oxides (SOx) and particular matter emissions.
Tri-fuel plant power purchase agreement
The output from the power plant is being sold to NEPCO, under a 25-year power purchase agreement signed between NEPCO and AAEPC.
Financing the world's biggest tri-fuel power plant
The power plant was constructed with an estimated investment of $812m. Korea Eximbank provided $320m in loan and $107m in guarantee for the project. Other financiers included Nippon Export and Investment Insurance (NEXI), Bank of Tokyo-Mitsubishi UFJ, KfW IPEX-Bank, Mizuho Corporate Bank, Standard Chartered Bank and Sumitomo Mitsui Banking Corporation.
The lender's technical adviser (LTA) was Hatch, whereas the international legal counsel was Ashurst.
Contractors involved with IPP3
"The plant operates with virtually no usage of water and generates approximately 35% less CO² emissions per kilowatt hour (kWh) compared to an oil-fired steam power plant."
The $552m engineering, procurement and construction (EPC) contract for the project was awarded to the consortium of Wärtsilä and Lotte Engineering & Construction. The former has also entered into a service agreement for the plant including a 15-year parts supply agreement and a five-year technical service agreement.
Engicon conducted the environmental impact assessment study for the project in collaboration with Parsons Brinckerhoff (PB).
The entire mechanical, electrical, and plumbing (MEP) works for the project were rendered by TechnoWatt Group, whereas the fabrication, supply and the power plant's structural steel installation works were performed by Steel Buildings.
Fatima Engineering supplied 20 sets of steam heating system for the HFO unloading station, while A Joo Fitting supplied forged fittings.
ALSTOM Grid
ALSTOM Grid can provide specialist technical services associated with the...
US Metals


text:
Home Trucks & SUVsTrucks
10 Reasons Why You Are Going to Want the 2018 Ford Expedition
by Micah Wright on October 8, 2019
2018 Ford Expedition | Ford
For today's families, it's crucial to have a vehicle that's just as active as they are. Ford has heard the calls for even more versatile SUVs from active millennial families. And it's answering with the all-new Expedition, which it heralds as the "smartest, most capable, and most adaptable Expedition ever."
Infused with enough technology to keep even the most electronically dependent passenger happy, you won't find many cut corners in the Explorer's big brother. Offering more power and towing prowess than any other full-size SUV on the market, as well as real off-road capability, Ford is positioning the new Expedition to score what video game fans would refer to as a "flawless victory" in its segment.
Unveiled at The Star Ford Center in Dallas, the larger and more streamlined Expedition is an exciting addition to the Blue Oval's impressive lineup. It also has a cause. In fall 2016, Ford and the Dallas Cowboys surprised local firefighters with an overhauled fire station. Now, the Detroit-based automaker is back for another round.
Working once more with the Dallas Cowboys and the local firefighter community, Ford's next move is to surprise one lucky first responder with an all-new Expedition. Here are 10 reasons why this generous donation has us thinking about volunteering down at the local station, and why SUV buyers could flip when it goes on sale later this year.
1. Ford's got you covered
Ford says the all-new Expedition will offer more driver-assist technology than any other full-size SUV on the market. Utilizing an all-new high-strength, aluminum-alloy body and overhauled steel frame (a recipe borrowed from its platform-mate, the F-150), the large SUV takes safety and efficiency to new levels. That means almost all the rugged perks of America's best-selling vehicle are in a family-friendly SUV that boasts more than 40 new features and driver-assist technologies.
2. Safe assumptions
In the Expedition, a class-exclusive active park assist has been partnered with 360-degree camera angles to make sure you park perfectly every time. On the open road, the Expedition offers a lane-keeping aid to reduce unintentional drifting. And adaptive cruise control pulls double-duty as a stop-and-go safety screen between vehicles. Collision-avoidance detection systems notify drivers about other vehicles and pedestrians. Plus, a slew of other advanced sensory systems work in tandem to make this SUV one of the safest money can buy.
3. Tech the halls
In addition to all the safety tech in the 2018 Expedition, fresh connectivity and convenience features are almost everywhere you look. This means passengers get things, such as a wireless charging pad that is large enough to house either an iPhone S+ or a non-exploding Samsung Note. The handy ledge also features a tapered lip that prevents devices from popping out while keeping the screen fully visible.
Passengers are going to love the Expedition's ability to stream their home cable programming on either the headrest-integrated screens or via hand-held devices. Ford's SYNC3 now supports both Apple CarPlay and Android Auto, and FordPass allows drivers to start, lock, unlock, locate, and run vehicle diagnostic scans remotely via their smartphones. There's also a Wi-Fi hotspot on board that can support up to 10 devices at once and features a 50-foot connection range.
4. Road trips, here we come
Passengers in every row have all the power they need courtesy of four 12-volt power points, six USB chargers, and a 110-volt outlet. There's also an available 12-speaker Bang & Olufsen PLAY premium audio system that's been tweaked by acoustic engineers to appease even the most finicky audiophile.
The new Expedition also sports an advanced cargo management system that features an adjustable shelf behind the third row for added storage space, and a special lip on the rear cargo floor keeps items from rolling out the back. Oh, and let's not forget that segment-exclusive optional panoramic glass roof, which spans two rows and is retractable.
5. We've got the power … and the drive
Because this has been designed to be the most capable Expedition ever, a modified 3.5-liter EcoBoost engine had to be engineered in order to back up these claims. Attached to a class-exclusive 10-speed automatic gearbox, the new Expedition boasts best-in-class towing capabilities. And with an electronic limited-slip differential available, there's little this SUV can't handle.
6. I 'towed' you so
Ford says "more than 50% of Expedition customers value towing, and 15% tow weekly or monthly." This explains why the 2018 model offers Pro Trailer Backup Assist. Turning a knob is a lot easier to explain than turning a boat launch into an 80-minute ordeal. Add that to the aforementioned best-in-class towing clout, and this SUV is a game changer for fans of cross-country hauls and crosstown tows, alike.
7. Time for some cabin acrobatics
The new Expedition has an extremely roomy, flexible interior that can seat up to eight with space to spare, thanks to its near minivan-like levels of customization. It's the first full-size SUV in history to feature a sliding second-row with tip-and-slide features, a design that provides access to the third row without the need to remove a child safety seat.
Having sat in the third row, we can attest that even 6-foot people will have loads of legroom. By allowing it to recline, Ford has turned the back bench into a comfortable place to be. Naturally, everything can be quickly folded flat via the push of a button to create a cargo area wide enough to handle 4-by-8-foot sheets of plywood or any other cumbersome payload.
8. Mother Nature has met her match
Taking an F-150 Raptor-like approach to off-road prowess was a massive move for Ford when it came time to engineer the latest Expedition. The latest Terrain Management System allows customers to choose various drive modes on the fly when inclement weather or treacherous terrain rear their snouts.
While a normal mode is dedicated to daily driving, sport is on hand to encourage spirited overtakes on the interstate. There's also a tow/haul mode, which focuses on torque and gearing. Eco massages fuel economy gains. Grass/gravel/snow tackles loose terrain. Sand handles low traction situations. And mud/rut mode is reserved for uneven surfaces.
9. Trim, proper, and adding to the roster
Ford will offer the 2018 Expedition in XLT, Limited, and Platinum trims. Additionally, an XL version will be available to fleet customers, so law enforcement, emergency services, and other state-run agencies can benefit from this new chassis. Ford claims this will be one of five new SUVs coming to its North American vehicle lineup in the next four years. With a similar powertrain and controls at the ready, could we see a Raptor version emerge at some point? Hey, we can dream.
10. Made true with red, white, and blue
The all-new Expedition is slated to arrive this fall, and Ford says it will be 100% built at its Kentucky Truck Plant in Louisville, Kentucky. Regardless of your political affiliations, if you swear by "Buy American," then this Ford's for you.


A Wireless HDMI Extender is a great equipment to have in the work place if you're looking to create a user friendly environment to display video across areas where routing a cable would be difficult or visually displeasing to use. These environments could be in meeting rooms, banquet halls, auditoriums, lounges or stadiums for example. Videos could be played by a computer, laptop, consoles or other disc playing multi-media devices and shown on a TV screen with virtually any size.
The table below suggests what resolution is best recommended for different types of multi-media tasks when using a Wireless HDMI extender.
By knowing the type of media consumption you'll need, you can pick a wireless extender suitable for you as each tier of wireless extender equipment (720p/1080p/2160p) becomes progressively more expensive.
The most common options are 2.4 GHz and 5 GHz wireless signals. Since 2.4 GHz is used by more devices, a Wireless HDMI extender using a 2.4 GHz wireless signal will become more susceptible to signal interference which may cause stuttering, lags and artifacts when transmitted to the receiving end.
A 5 GHz wireless signal is not only stable (direct line of sight); it also delivers more data through its signal due to its higher bandwidth.
It is an added bonus for wireless extenders to supports multi-channel wireless frequencies as this will minimize wireless interference the most and provide the most stable signal quality.
If the source device you're using supports HDMI out signals, it is best to get a wireless extender which supports HDMI input signals and also to make sure the correct HDMI cables are used between your source device and transmitting module for each wireless extender as a lower specification cable could bottleneck the data being passed through reducing overall image quality on the output device.
You'll need to make sure the transmitter and receiver is able to support multiple displays simultaneously as not all wireless extenders can extend images to multiple displays. Check if you are able to purchase a single receiver or if sold together for the transmitter and receiver only.
If your source device (such as a Blu-ray player, DVD player, PlayStation, Xbox, Apple TV, Google Chromecast etc.) requires a remote control and you wish to extend the display to a place where the remote control cannot control it, then it is best to find a wireless extender which supports an IR extension module to control your source device from your extended output device located in a further area.
The broadcasting latency will determine the amount of delay between your transmitter and receiver modules. A wireless latency with a maximum of 200ms would be suitable for most media consumption such as watching videos, doing presentations, looking at pictures or doing some gaming.
Wireless extenders are extremely useful equipment's which can solve the trouble of routing cables across difficult terrains or environments. It is important to consider the factors above when making a purchase to avoid multiple situations which may occur as described above.


text:
Social Enterprises in the Maritimes
National & International Social Enterprises
Pitch & Skills Development Competitions
Community Champions & Social Enterprises
Return to pond-deshpande centre website
We are so fortunate to have social enterprises in our region that are flourishing. They can provide an example of what various social enterprises can look like, whether that be for or non-profit. Additionally, there are many organizations that are championing this movement. We welcome you to take a deeper look!
About the pond-deshpande centre
The Pond-Deshpande Centre acts as a catalyst to advance innovation and entrepreneurship in New Brunswick and the region by facilitating collaboration among entrepreneurs, emerging and aspiring companies, students, faculty and alumni.
The PDC works within the innovation and entrepreneurship ecosystem to create learning & mentorship opportunities for aspiring innovators that will provide them with a sound foundation in technical and social entrepreneurship, give them the opportunity to engage in the experience and explore their possibilities for success.
The PDC also serves as a resource for new entrepreneurs to help translate their ideas into companies, products or services.


SB 1881 authorizes an adult with a disability to voluntarily, without undue influence or coercion, or without creating a guardianship, enter into a supported decision-making agreement with a supporter.
Provides a less restrictive alternative to guardianship for adults with disabilities who need assistance with decisions regarding daily living but who are not considered incapacitated persons for purposes of establishing a guardianship.
Requires a supported decision-making agreement must be signed by the principal and supporter before a Notary or two witnesses at least 14 years of age.
Requires that a supported decision-making agreement must be signed voluntarily, without coercion or undue influence.
Provides a statutory supported decision-making agreement form.
According to the bill analysis, while guardianship sometimes may be necessary, a person should not be presumed to need a guardian simply because of advanced age or the presence of a physical, cognitive, or mental disability. An individual should be given the opportunity to avoid or limit guardianship through available alternatives. Senate Bill 1881 seeks to provide such an alternative.
SB 1881 requires a supported decision-making agreement to be signed voluntarily and without coercion by the principal and the supporter in the presence of two witnesses or a Notary. Notaries performing the notarial act on the agreement should note that a while the notarial certificate is an acknowledgment -- technically only requiring the signature to be acknowledged before the Notary -- the statute says that if notarized, the signature must be witnessed by the Notary.


Hi. My name is Greg and I am the web master here at Baseball Trivia HQ.
I love baseball. I also love baseball statistics and baseball facts. And baseball trivia questions. I thought I would combine all of my passions into one amazing baseball trivia website. I believe this is the most comprehensive baseball trivia game ever created. I hope you enjoy playing as much as I enjoyed building these games.
My goal is to provide an informative and entertaining baseball trivia site. If you have any questions whatsoever, please contact me using the contact form linked at the bottom of each page and I will be happy to answer any questions.


The Club had a tank build contest at the monthly meeting on April 10, 2019. 15 great models were entered. The winner was Mike MacDonald for his Tiger 1. The WW II Sherman Tank was well represented with 2nd place going to Bill Walch's Sherman "Fury".
Enjoy the pictures of this great contest. Thanks to those who participated and a special thanks to Bob Wilson for documenting and photographing the event. You can click on the images for a full sized view.
2nd Place, Bill Walch's Sherman "Fury"


Journal Reference: Kleiss J, E Riley, C Long, L Riihimaki, L Berg, V Morris, and E Kassianov. 2018. "Cloud Area Distributions of Shallow Cumuli: A New Method for Ground-Based Images." Atmosphere, 9(7), 10.3390/atmos9070258.
Complex interactions between Earth's surface and the atmosphere, such as the exchange of water and energy, often involve clouds and the combination of their size and shape—or cloud equivalent diameters. When it comes to shallow cumuli—puffy, cotton ball-like clouds with rapidly evolving cloud equivalent diameters—available ground-based and satellite sensors fall short of capturing these changes at the level of detail required to assess and improve the representation of shallow cumuli in atmospheric models. Researchers from the U.S. Department of Energy (DOE), Lewis & Clark College, and the Cooperative Institute for Research in Environmental Sciences at the University of Colorado, Boulder, teamed up to develop a method for obtaining the required information on cloud equivalent diameter with high time resolution. They introduced a simple, computationally inexpensive method using low-cost, ground-based sky images.
The new method provides a previously unavailable data set for process studies of the convective boundary layer and for evaluation of shallow cumuli growth, maturation, and dissipation in cloud-resolving models. Because many atmospheric research sites worldwide deploy low-cost, ground-based sky imagers, the research team plans to apply the new method to existing and future studies at different locations.
Shallow cumuli are usually small (less than 1 kilometer across), but their complex, rapidly changing shape and size make it notoriously difficult to track their evolution with standard, high-cost, ground-based and satellite observations, and subsequently represent them accurately in atmospheric models. However, visual observations of shallow cumuli are very straightforward, as these clouds are very easy to see floating in the sky overhead. Taking advantage of the strong visual contrast between the clouds and blue sky, the research team used available ground-based sky images to estimate the area of individual clouds at a previously unachievable rate.
Researchers looked at images obtained from a total sky imager and complementary information on cloud base height provided by lidar measurements to estimate the cloud equivalent diameter over a wide range of cloud sizes (about 0.01 to 3.5 kilometers) with 30-second time resolution. The team demonstrated the feasibility of the new method by comparing cloud area distributions obtained from ground-based and satellite images collected from 2004 to 2017 at the DOE Atmospheric Radiation Measurement (ARM) user facility's Southern Great Plains atmospheric observatory. The new method provides unique cloud area information required for better understanding of the lifetime of shallow cumuli. Because of its simplicity and the worldwide deployment of sky imagers, the method has the potential to become widely used for important climate-related research applications.


text:
Europe powers ahead as deal volumes hit record
The UK remains out in front but opportunities are growing across the continent.
The European markets are rebounding fast. Figures from the latest Alternative Lender Deal Tracker, published by Deloitte, show that European non-bank deals doubled year-on-year in the first half of 2021, with 147 direct lending transactions taking place in the second quarter on the back of 186 in the first three months of the year.
That total of 333 transactions completed in the first half is only a whisker behind the 386 direct lending deals that closed in the whole of 2020, after deal volumes saw a dramatic covid-induced slowdown. Leaving the pandemic aside, though, Q2 2021 is the busiest second quarter on record, according to Deloitte, as many credit investors across Europe report business levels unlike anything they have ever seen before.
The UK market continues to be the most mature of Europe's direct lending markets, accounting for more than a third of all the deals taking place on the continent, and followed at some distance by France, Germany and then the Benelux. But across Europe, private lenders continue to grow their market share against the banks, with debt funds able to both defend and enhance their position thanks to growing appetite for their offering from both institutional investors and borrowers.
These latest figures show the impact of the pandemic on deal activity has faded quickly and the market has proved its resilience with record European unitranche activity in the first half of 2021. High-quality assets continue to come to market and debt funds are playing a fast-growing role in financing deals across all European markets.