165 lines
3.9 KiB
Lua
165 lines
3.9 KiB
Lua
-- Mock premake
|
|
require "mock"
|
|
require "functools"
|
|
require "itertools"
|
|
require "utils"
|
|
|
|
local function _get(t, name, default)
|
|
res = t[name]
|
|
if res == nil then
|
|
res = default or {}
|
|
t[name] = res
|
|
end
|
|
return res
|
|
end
|
|
|
|
PremakeMock = Mock:New{
|
|
-- TODO: Probably better to use getfenv
|
|
mocked = _G,
|
|
options = {
|
|
flags = true,
|
|
defines = true,
|
|
language = true,
|
|
buildoptions = true,
|
|
linkoptions = true,
|
|
libdirs = true,
|
|
includedirs = true,
|
|
kind = false,
|
|
objdir = true,
|
|
targetdir = true,
|
|
pchsource = true,
|
|
pchheader = true,
|
|
excludefilefrombuild = true,
|
|
excludefilefrompch = true,
|
|
targetname = true,
|
|
links = true,
|
|
location = false }
|
|
}
|
|
|
|
function PremakeMock:Check(cond)
|
|
if not cond then
|
|
showit("Assertion failed", {
|
|
cur_solution = self.cur_solution,
|
|
cur_configuration = self.cur_configuration,
|
|
cur_project = self.cur_project,
|
|
cur_context = self.cur_context },
|
|
self.calls)
|
|
end
|
|
return cond
|
|
end
|
|
|
|
function PremakeMock:mock_solution(name)
|
|
assert(self:Check(self.solutions))
|
|
self.cur_solution = _get(self.solutions, name, {
|
|
projects = {},
|
|
configurations = {}
|
|
})
|
|
self.cur_context = self.cur_solution
|
|
self.cur_configuration = nil
|
|
return self.cur_solution
|
|
end
|
|
|
|
function PremakeMock:mock_project(name)
|
|
assert(self:Check(self.cur_solution))
|
|
assert(self:Check(self.cur_solution.projects))
|
|
self.cur_project = _get(self.cur_solution.projects, name, {
|
|
files = {},
|
|
configurations = {}
|
|
})
|
|
self.cur_context = self.cur_project
|
|
self.cur_configuration = nil
|
|
return self.cur_project
|
|
end
|
|
|
|
function PremakeMock:mock_configuration(name)
|
|
assert(self:Check(self.cur_context))
|
|
assert(self:Check(self.cur_context.configurations))
|
|
if type(name) == "table" then
|
|
assert(#name == 1)
|
|
name = name[1]
|
|
end
|
|
self.cur_configuration = _get(self.cur_context.configurations, name, {})
|
|
return self.cur_configuration
|
|
end
|
|
|
|
|
|
function PremakeMock:mock_files(fs)
|
|
assert(self:Check(self.cur_project))
|
|
if type(fs) == "string" then
|
|
fs = {fs}
|
|
end
|
|
self.cur_project.files = concat(self.cur_project.files, fs)
|
|
end
|
|
|
|
function PremakeMock:mock_configurations(names)
|
|
assert(self:Check(self.cur_context))
|
|
for name in iter(names) do
|
|
configuration(name)
|
|
end
|
|
self.cur_configuration = nil
|
|
end
|
|
|
|
function PremakeMock:_optionmock(name, config, value)
|
|
local cfg = self.cur_context
|
|
if config then
|
|
cfg = self.cur_configuration or self.cur_context
|
|
end
|
|
assert(self:Check(cfg))
|
|
if type(value) ~= "table" then
|
|
value = { value }
|
|
end
|
|
cfg[name] = mergetables(cfg[name], value)
|
|
end
|
|
|
|
function PremakeMock:Install()
|
|
-- Create mock for basic options
|
|
local mock_option = partial(self._optionmock, self)
|
|
for _option, _config in pairs(self.options) do
|
|
self:Mock(_option, partial(mock_option, _option, _config))
|
|
end
|
|
|
|
Mock.Install(self)
|
|
|
|
self.solutions = {}
|
|
self.cur_solution = nil
|
|
self.cur_configuration = nil
|
|
self.cur_project = nil
|
|
self.cur_context = nil
|
|
end
|
|
|
|
OSMock = Mock:New{
|
|
-- TODO: Probably better to use getfenv
|
|
mocked = os
|
|
}
|
|
|
|
function OSMock:mock_execute(cmd)
|
|
printf("Executing %s", cmd)
|
|
end
|
|
|
|
MockedFile = {}
|
|
|
|
function MockedFile:New(o)
|
|
o = o or {}
|
|
setmetatable(o, self)
|
|
self.__index = self
|
|
return o
|
|
end
|
|
|
|
function MockedFile:write(body)
|
|
self.contents = (self.contents or "") .. body
|
|
end
|
|
|
|
IOMock = Mock:New{
|
|
mocked = io
|
|
}
|
|
|
|
function IOMock:mock_open(fn, mod)
|
|
if mod == "w" then
|
|
self.files = self.files or {}
|
|
assert(self.files[fn] == nil)
|
|
self.files[fn] = MockedFile:New()
|
|
return self.files[fn], 0
|
|
else
|
|
return self.originals.open(fn, mod)
|
|
end
|
|
end
|