// Singular with various newline formats
auto f = [] -> void {
    return;
};

auto f = [] -> void {
    return;
}();

auto f = [] -> void
{
    return;
}();

auto f = 
[] -> void {
    return;
};

auto f = 
[] -> void
{
    return;
};

auto f
    = [] -> void {
        int i = 0;
        return;
    };

auto f
    = []
      {
          int i = 0;
          return;
      };

// Nested lambda
auto f = [] {
    auto g = [] {
        auto h = [] {
            return;
        };
        return;
    };
    return;
};

auto f = [] {
    auto g = []
    {
        auto h = [] {
            return;
        };
        return;
    };
    return;
};

auto f = []
{
    auto g = [] {
        auto h = []
        {
            return;
        };
        return;
    };
    return;
};

// Nested lambda within functions
FuncA(
    [] { return; },
    [] { return; }
);

FuncB([] { return; },
    [] { return; }
);

FuncC([] { return; },
    [] { return; }
)();

FuncD([] { return; },
    [] { return; })();

FuncE([] { return; },
    [] { return; });

A(
        B([] (const std::string &s) -> bool {
            s = "hello";
            return true;
            }), 1
        );

A(
        B(
            [] (const std::string &s) -> bool {
            s = "hello";
            return true;
            }
            ), 1
        );

// Inside scope
{
    std::thread([](const char *c) {
            std::cout << c << std::endl;
        }).detach();

    std::thread(
            [](const char *c) {
            std::cout << c << std::endl;
        }
        ).detach();

    auto f = [&](int a) {
            return b;
        };

    auto f = [&](int a)
        {
            return b;
        };
}

Func(std::count_if(v.begin(), v.end(), [&](const auto &a) {
            return a == 3;
    }));

Func(
        std::count_if(v.begin(), v.end(), [&](const auto &a)
            {
            return a == 3;
    }));

Func(
        std::count_if(v.begin(), v.end(), [&](const auto &a) {
            return a == 3;
    }));

Func(
        std::count_if(v.begin(), v.end(), [&](const auto &a) {
            return a == 3;
    })
    );

// Test case from issue #3116
const auto compare = [] (const auto i, const auto j)
{
    return i >= j;
};

std::sort(
    vector.begin(),
    vector.end(),
    [] (const auto i, const auto j)
{
    return i >= j;
}
);

// Test case from issue #3116
if(isWidgetOfCurrentRow)
{
    it = std::find_if(
            reloaded.begin(),
            reloaded.end(),
            [&rowGuid](const auto& device)
            {
            return (device.thingGUID == rowGuid && !device.isWidget);
            }
            );
}
else
{
    it = std::find_if(
            reloaded.begin(),
            reloaded.end(),
            [&rowGuid](const auto& device)
            {
            return device.thingGUID == rowGuid;
            }
            );
}

// Test case from issue 1296 and some variants
obj->Func([&](int a)
        {
        return b;
        });

obj->Func([] -> int
        {
        return b;
        });

obj->Func([]
        {
        return b;
        }
        );

obj->Func(
        Func([]
        {
        return b;
        })
        );
